system-testing 1.0.35 → 1.0.37

package/build/index.js

@@ -0,0 +1,3 @@
+const stub = "Hello world";
+export { stub };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxJQUFJLEdBQUcsYUFBYSxDQUFBO0FBRTFCLE9BQU8sRUFBQyxJQUFJLEVBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHN0dWIgPSBcIkhlbGxvIHdvcmxkXCJcblxuZXhwb3J0IHtzdHVifVxuIl19

package/{dist → build}/system-test-browser-helper.d.ts

@@ -2,7 +2,7 @@ export default class SystemTestBrowserHelper {
     static current(): SystemTestBrowserHelper;
     communicator: SystemTestCommunicator;
     _enabled: boolean;
-    events: EventEmitter<any>;
+    events: EventEmitter<string | symbol, any>;
     startScoundrel(): Promise<void>;
     scoundrelWs: WebSocket;
     scoundrelClientWebSocket: ClientWebSocket;
@@ -103,6 +103,6 @@ export default class SystemTestBrowserHelper {
     sendQuery(sql: string): Promise<Array<Record<string, any>>>;
 }
 import SystemTestCommunicator from "./system-test-communicator.js";
-import EventEmitter from "events";
+import { EventEmitter } from "eventemitter3";
 import ClientWebSocket from "scoundrel-remote-eval/build/client/connections/web-socket/index.js";
 import Client from "scoundrel-remote-eval/build/client/index.js";

package/build/system-test-browser-helper.js

@@ -0,0 +1,238 @@
+// @ts-check
+import Client from "scoundrel-remote-eval/build/client/index.js";
+import ClientWebSocket from "scoundrel-remote-eval/build/client/connections/web-socket/index.js";
+import { digg } from "diggerize";
+import { EventEmitter } from "eventemitter3";
+import SystemTestCommunicator from "./system-test-communicator.js";
+/** @type {{systemTestBrowserHelper: SystemTestBrowserHelper | null}} */
+const shared = {
+    systemTestBrowserHelper: null
+};
+export default class SystemTestBrowserHelper {
+    static current() {
+        if (!shared.systemTestBrowserHelper) {
+            throw new Error("No current SystemTestBrowserHelper set");
+        }
+        return shared.systemTestBrowserHelper;
+    }
+    constructor() {
+        /**
+         * @param {any[]} args
+         * @returns {void}
+         */
+        this.fakeConsoleError = (...args) => {
+            this.communicator.sendCommand({ type: "console.error", value: this.consoleLogMessage(args) });
+            if (this.originalConsoleError) {
+                return this.originalConsoleError(...args);
+            }
+        };
+        /**
+         * @param {any[]} args
+         * @returns {void}
+         */
+        this.fakeConsoleLog = (...args) => {
+            this.communicator.sendCommand({ type: "console.log", value: this.consoleLogMessage(args) });
+            if (this.originalConsoleLog) {
+                return this.originalConsoleLog(...args);
+            }
+        };
+        /**
+         * @param {{data: {path: string, type: string}}} args
+         * @returns {Promise<{result: string} | void>}
+         */
+        this.onCommand = async ({ data }) => {
+            if (data.type == "initialize") {
+                this.events.emit("initialize");
+                if (this._onInitializeCallback) {
+                    await this._onInitializeCallback();
+                }
+                return { result: "initialized" };
+            }
+            else if (data.type == "visit") {
+                this.events.emit("navigate", { path: data.path });
+            }
+            else if (data.type == "dismissTo") {
+                this.events.emit("dismissTo", { path: data.path });
+            }
+            else {
+                throw new Error(`Unknown command type for SystemTestBrowserHelper: ${data.type}`);
+            }
+        };
+        this.communicator = new SystemTestCommunicator({ parent: this, onCommand: this.onCommand });
+        this._enabled = false;
+        this.events = new EventEmitter();
+        shared.systemTestBrowserHelper = this;
+        this.startScoundrel();
+    }
+    async startScoundrel() {
+        this.scoundrelWs = new WebSocket("http://localhost:8090");
+        // @ts-expect-error
+        this.scoundrelClientWebSocket = new ClientWebSocket(this.scoundrelWs);
+        await this.scoundrelClientWebSocket.waitForOpened();
+        this.scoundrelClient = new Client(this.scoundrelClientWebSocket);
+        this.events.emit("scoundrelStarted");
+    }
+    waitForScoundrelStarted() {
+        return new Promise((resolve) => {
+            if (this.scoundrelClient) {
+                resolve(undefined);
+            }
+            else {
+                this.events.once("scoundrelStarted", () => {
+                    resolve(undefined);
+                });
+            }
+        });
+    }
+    getScoundrel() {
+        if (!this.scoundrelClient) {
+            throw new Error("Scoundrel client is not started yet");
+        }
+        return this.scoundrelClient;
+    }
+    connectOnError() {
+        window.addEventListener("error", (event) => {
+            this.handleError({
+                type: "error",
+                error: event.error,
+                errorClass: event.error?.name,
+                file: event.filename,
+                line: event.lineno,
+                message: event.message || "Unknown error",
+                url: window.location.href
+            });
+        });
+    }
+    connectUnhandledRejection() {
+        window.addEventListener("unhandledrejection", (event) => {
+            this.handleError({
+                type: "unhandledrejection",
+                error: event.reason,
+                errorClass: "UnhandledRejection",
+                message: event.reason.message || event.reason || "Unhandled promise rejection without a message",
+                url: window.location.href
+            });
+        });
+    }
+    /**
+     * @param {object} data
+     * @param {string} [data.backtrace]
+     * @param {Error} [data.error]
+     * @param {string} [data.errorClass]
+     * @param {string} [data.file]
+     * @param {number} [data.line]
+     * @param {string} [data.message]
+     * @param {string} [data.type]
+     * @param {string} [data.url]
+     * @returns {void}
+     */
+    handleError(data) {
+        let backtrace;
+        if (data.error && data.error.stack) {
+            backtrace = data.error.stack.split("\n");
+            backtrace.shift();
+            backtrace = backtrace.join("\n");
+        }
+        else if (data.file) {
+            backtrace = `${data.file}:${data.line}`;
+        }
+        data.backtrace = backtrace;
+        this.communicator.sendCommand(data);
+    }
+    /**
+     * @returns {void}
+     */
+    connectWebSocket() {
+        this.ws = new WebSocket("ws://localhost:1985");
+        this.communicator.ws = this.ws;
+        this.ws.addEventListener("error", digg(this, "communicator", "onError"));
+        this.ws.addEventListener("open", digg(this, "communicator", "onOpen"));
+        this.ws.addEventListener("message", (event) => this.communicator.onMessage(event.data));
+    }
+    /**
+     * @returns {void}
+     */
+    enableOnBrowser() {
+        this._enabled = true;
+        this.connectWebSocket();
+        this.connectOnError();
+        this.connectUnhandledRejection();
+        this.overrideConsoleLog();
+    }
+    /**
+     * @returns {boolean}
+     */
+    getEnabled() { return this._enabled; }
+    /**
+     * @returns {EventEmitter}
+     */
+    getEvents() { return this.events; }
+    /**
+     * @param {any} arg
+     * @param {any[]} [scannedObjects]
+     * @returns {any}
+     */
+    consoleLogMessage(arg, scannedObjects = []) {
+        if (Array.isArray(arg)) {
+            if (scannedObjects.includes(arg)) {
+                return "[recursive]";
+            }
+            else {
+                scannedObjects.push(arg);
+            }
+            const result = [];
+            for (const value of arg) {
+                result.push(this.consoleLogMessage(value, scannedObjects));
+            }
+            return result;
+        }
+        else if (Object.prototype.toString.call(arg) === '[object Object]') {
+            if (scannedObjects.includes(arg)) {
+                return "[recursive]";
+            }
+            else {
+                scannedObjects.push(arg);
+            }
+            /** @type {Record<string, any>} */
+            const result = {};
+            for (const key in arg) {
+                result[key] = this.consoleLogMessage(arg[key], scannedObjects);
+            }
+            return result;
+        }
+        else if (typeof arg == "object") {
+            return `[object ${arg?.constructor?.name}]`;
+        }
+        else {
+            return arg;
+        }
+    }
+    /**
+     * @param {function() : void} callback
+     * @returns {void}
+     */
+    onInitialize(callback) {
+        this._onInitializeCallback = callback;
+    }
+    /**
+     * @returns {void}
+     */
+    overrideConsoleLog() {
+        if (this.originalConsoleError || this.originalConsoleLog) {
+            throw new Error("Console methods has already been overridden!");
+        }
+        this.originalConsoleError = console.error;
+        this.originalConsoleLog = console.log;
+        console.error = this.fakeConsoleError;
+        console.log = this.fakeConsoleLog;
+    }
+    /**
+     * @param {string} sql
+     * @returns {Promise<Array<Record<string, any>>>}
+     */
+    async sendQuery(sql) {
+        // @ts-expect-error
+        return await this.communicator.sendCommand({ type: "query", sql });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test-browser-helper.js","sourceRoot":"","sources":["../src/system-test-browser-helper.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Client from \"scoundrel-remote-eval/build/client/index.js\"\nimport ClientWebSocket from \"scoundrel-remote-eval/build/client/connections/web-socket/index.js\"\nimport {digg} from \"diggerize\"\nimport {EventEmitter} from \"eventemitter3\"\n\nimport SystemTestCommunicator from \"./system-test-communicator.js\"\n\n/** @type {{systemTestBrowserHelper: SystemTestBrowserHelper | null}} */\nconst shared = {\n  systemTestBrowserHelper: null\n}\n\nexport default class SystemTestBrowserHelper {\n  static current() {\n    if (!shared.systemTestBrowserHelper) {\n      throw new Error(\"No current SystemTestBrowserHelper set\")\n    }\n\n    return shared.systemTestBrowserHelper\n  }\n\n  constructor() {\n    this.communicator = new SystemTestCommunicator({parent: this, onCommand: this.onCommand})\n    this._enabled = false\n    this.events = new EventEmitter()\n\n    shared.systemTestBrowserHelper = this\n\n    this.startScoundrel()\n  }\n\n  async startScoundrel() {\n    this.scoundrelWs = new WebSocket(\"http://localhost:8090\")\n\n    // @ts-expect-error\n    this.scoundrelClientWebSocket = new ClientWebSocket(this.scoundrelWs)\n\n    await this.scoundrelClientWebSocket.waitForOpened()\n\n    this.scoundrelClient = new Client(this.scoundrelClientWebSocket)\n    this.events.emit(\"scoundrelStarted\")\n  }\n\n  waitForScoundrelStarted() {\n    return new Promise((resolve) => {\n      if (this.scoundrelClient) {\n        resolve(undefined)\n      } else {\n        this.events.once(\"scoundrelStarted\", () => {\n          resolve(undefined)\n        })\n      }\n    })\n  }\n\n  getScoundrel() {\n    if (!this.scoundrelClient) {\n      throw new Error(\"Scoundrel client is not started yet\")\n    }\n\n    return this.scoundrelClient\n  }\n\n  connectOnError() {\n    window.addEventListener(\"error\", (event) => {\n      this.handleError({\n        type: \"error\",\n        error: event.error,\n        errorClass: event.error?.name,\n        file: event.filename,\n        line: event.lineno,\n        message: event.message || \"Unknown error\",\n        url: window.location.href\n      })\n    })\n  }\n\n  connectUnhandledRejection() {\n    window.addEventListener(\"unhandledrejection\", (event) => {\n      this.handleError({\n        type: \"unhandledrejection\",\n        error: event.reason,\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || event.reason || \"Unhandled promise rejection without a message\",\n        url: window.location.href\n      })\n    })\n  }\n\n  /**\n   * @param {object} data\n   * @param {string} [data.backtrace]\n   * @param {Error} [data.error]\n   * @param {string} [data.errorClass]\n   * @param {string} [data.file]\n   * @param {number} [data.line]\n   * @param {string} [data.message]\n   * @param {string} [data.type]\n   * @param {string} [data.url]\n   * @returns {void}\n   */\n  handleError(data) {\n    let backtrace\n\n    if (data.error && data.error.stack) {\n      backtrace = data.error.stack.split(\"\\n\")\n      backtrace.shift()\n      backtrace = backtrace.join(\"\\n\")\n    } else if (data.file) {\n      backtrace = `${data.file}:${data.line}`\n    }\n\n    data.backtrace = backtrace\n\n    this.communicator.sendCommand(data)\n  }\n\n  /**\n   * @returns {void}\n   */\n  connectWebSocket() {\n    this.ws = new WebSocket(\"ws://localhost:1985\")\n    this.communicator.ws = this.ws\n    this.ws.addEventListener(\"error\", digg(this, \"communicator\", \"onError\"))\n    this.ws.addEventListener(\"open\", digg(this, \"communicator\", \"onOpen\"))\n    this.ws.addEventListener(\"message\", (event) => this.communicator.onMessage(event.data))\n  }\n\n  /**\n   * @returns {void}\n   */\n  enableOnBrowser() {\n    this._enabled = true\n    this.connectWebSocket()\n    this.connectOnError()\n    this.connectUnhandledRejection()\n    this.overrideConsoleLog()\n  }\n\n  /**\n   * @returns {boolean}\n   */\n  getEnabled() { return this._enabled }\n\n  /**\n   * @returns {EventEmitter}\n   */\n  getEvents() { return this.events }\n\n  /**\n   * @param {any[]} args\n   * @returns {void}\n   */\n  fakeConsoleError = (...args) => {\n    this.communicator.sendCommand({type: \"console.error\", value: this.consoleLogMessage(args)})\n\n    if (this.originalConsoleError) {\n      return this.originalConsoleError(...args)\n    }\n  }\n\n  /**\n   * @param {any[]} args\n   * @returns {void}\n   */\n  fakeConsoleLog = (...args) => {\n    this.communicator.sendCommand({type: \"console.log\", value: this.consoleLogMessage(args)})\n\n    if (this.originalConsoleLog) {\n      return this.originalConsoleLog(...args)\n    }\n  }\n\n  /**\n   * @param {any} arg\n   * @param {any[]} [scannedObjects]\n   * @returns {any}\n   */\n  consoleLogMessage(arg, scannedObjects = []) {\n    if (Array.isArray(arg)) {\n      if (scannedObjects.includes(arg)) {\n        return \"[recursive]\"\n      } else {\n        scannedObjects.push(arg)\n      }\n\n      const result = []\n\n      for (const value of arg) {\n        result.push(this.consoleLogMessage(value, scannedObjects))\n      }\n\n      return result\n    } else if (Object.prototype.toString.call(arg) === '[object Object]') {\n      if (scannedObjects.includes(arg)) {\n        return \"[recursive]\"\n      } else {\n        scannedObjects.push(arg)\n      }\n\n      /** @type {Record<string, any>} */\n      const result = {}\n\n      for (const key in arg) {\n        result[key] = this.consoleLogMessage(arg[key], scannedObjects)\n      }\n\n      return result\n    } else if (typeof arg == \"object\") {\n      return `[object ${arg?.constructor?.name}]`\n    } else {\n      return arg\n    }\n  }\n\n  /**\n   * @param {{data: {path: string, type: string}}} args\n   * @returns {Promise<{result: string} | void>}\n   */\n  onCommand = async ({data}) => {\n    if (data.type == \"initialize\") {\n      this.events.emit(\"initialize\")\n\n      if (this._onInitializeCallback) {\n        await this._onInitializeCallback()\n      }\n\n      return {result: \"initialized\"}\n    } else if (data.type == \"visit\") {\n      this.events.emit(\"navigate\", {path: data.path})\n    } else if (data.type == \"dismissTo\") {\n      this.events.emit(\"dismissTo\", {path: data.path})\n    } else {\n      throw new Error(`Unknown command type for SystemTestBrowserHelper: ${data.type}`)\n    }\n  }\n\n  /**\n   * @param {function() : void} callback\n   * @returns {void}\n   */\n  onInitialize(callback) {\n    this._onInitializeCallback = callback\n  }\n\n  /**\n   * @returns {void}\n   */\n  overrideConsoleLog() {\n    if (this.originalConsoleError || this.originalConsoleLog) {\n      throw new Error(\"Console methods has already been overridden!\")\n    }\n\n    this.originalConsoleError = console.error\n    this.originalConsoleLog = console.log\n\n    console.error = this.fakeConsoleError\n    console.log = this.fakeConsoleLog\n  }\n\n  /**\n   * @param {string} sql\n   * @returns {Promise<Array<Record<string, any>>>}\n   */\n  async sendQuery(sql) {\n    // @ts-expect-error\n    return await this.communicator.sendCommand({type: \"query\", sql})\n  }\n}\n"]}

package/build/system-test-communicator.js

@@ -0,0 +1,105 @@
+// @ts-check
+export default class SystemTestCommunicator {
+    /**
+     * @param {object} args
+     * @param {(args: Record<string, any>) => Promise<{result: string} | void>} args.onCommand
+     * @param {object} [args.parent]
+     */
+    constructor({ onCommand, parent }) {
+        /** @type {Record<string, {resolve: (data: any) => void, reject: (data: any) => void}>} */
+        this._responses = {};
+        /** @type {Record<string, any>} */
+        this._sendQueue = [];
+        this._sendQueueCount = 0;
+        /** @type {WebSocket | null} */
+        this.ws = null;
+        /** @param {Error} error */
+        this.onError = (error) => {
+            console.error("onWebSocketClientError", error);
+        };
+        /** @param {string} rawData */
+        this.onMessage = async (rawData) => {
+            /** @type {{data: any, id: number, type: string, isTrusted?: boolean}} */
+            const data = JSON.parse(rawData);
+            if (data.isTrusted) {
+                // Ignore
+            }
+            else if (data.type == "command") {
+                try {
+                    const result = await this.onCommand({ data: data.data });
+                    this.respond(data.id, { result });
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        this.respond(data.id, { error: error.message });
+                    }
+                    else {
+                        this.respond(data.id, { error: error });
+                    }
+                }
+            }
+            else if (data.type == "response") {
+                const response = this._responses[data.id];
+                if (!response) {
+                    throw new Error(`No such response: ${data.id}`);
+                }
+                delete this._responses[data.id];
+                if (data.data.error) {
+                    response.reject(data.data.error);
+                }
+                else {
+                    response.resolve(data.data.result);
+                }
+            }
+            else {
+                throw new Error(`Unknown type for SystemTestCommunicator: ${data.type}: ${JSON.stringify(data)}`);
+            }
+        };
+        this.onOpen = () => {
+            this.flushSendQueue();
+        };
+        this.onCommand = onCommand;
+        this.parent = parent;
+    }
+    flushSendQueue() {
+        while (this._sendQueue.length !== 0) {
+            const data = this._sendQueue.shift();
+            if (!this.ws || this.ws.readyState !== 1) {
+                throw new Error("WebSocket is not open");
+            }
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    /**
+     * @param {Record<string, any>} data
+     * @returns {void}
+     */
+    send(data) {
+        this._sendQueue.push(data);
+        if (this.ws.readyState == 1) {
+            this.flushSendQueue();
+        }
+    }
+    /**
+     * Sends a command and returns a promise that resolves with the response.
+     * @param {Record<string, any>} data - The command data to send.
+     * @returns {Promise<void>} A promise that resolves with the response data.
+     */
+    sendCommand(data) {
+        return new Promise((resolve, reject) => {
+            const id = this._sendQueueCount;
+            this._sendQueueCount += 1;
+            this._responses[id] = { resolve, reject };
+            this.send({ type: "command", id, data });
+        });
+    }
+    /**
+     * @param {number} id
+     * @param {Record<string, any>} data
+     * @returns {void}
+     */
+    respond(id, data) {
+        this.send({ type: "response", id, data });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test-communicator.js","sourceRoot":"","sources":["../src/system-test-communicator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nexport default class SystemTestCommunicator {\n  /** @type {Record<string, {resolve: (data: any) => void, reject: (data: any) => void}>} */\n  _responses = {}\n\n  /** @type {Record<string, any>} */\n  _sendQueue = []\n\n  _sendQueueCount = 0\n\n  /** @type {WebSocket | null} */\n  ws = null\n\n  /**\n   * @param {object} args\n   * @param {(args: Record<string, any>) => Promise<{result: string} | void>} args.onCommand\n   * @param {object} [args.parent]\n   */\n  constructor({onCommand, parent}) {\n    this.onCommand = onCommand\n    this.parent = parent\n  }\n\n  flushSendQueue() {\n    while (this._sendQueue.length !== 0) {\n      const data = this._sendQueue.shift()\n\n      if (!this.ws || this.ws.readyState !== 1) {\n        throw new Error(\"WebSocket is not open\")\n      }\n\n      this.ws.send(JSON.stringify(data))\n    }\n  }\n\n  /** @param {Error} error */\n  onError = (error) => {\n    console.error(\"onWebSocketClientError\", error)\n  }\n\n  /** @param {string} rawData */\n  onMessage = async (rawData) => {\n    /** @type {{data: any, id: number, type: string, isTrusted?: boolean}} */\n    const data = JSON.parse(rawData)\n\n    if (data.isTrusted) {\n      // Ignore\n    } else if (data.type == \"command\") {\n      try {\n        const result = await this.onCommand({data: data.data})\n\n        this.respond(data.id, {result})\n      } catch (error) {\n        if (error instanceof Error) {\n          this.respond(data.id, {error: error.message})\n        } else {\n          this.respond(data.id, {error: error})\n        }\n      }\n    } else if (data.type == \"response\") {\n      const response = this._responses[data.id]\n\n      if (!response) {\n        throw new Error(`No such response: ${data.id}`)\n      }\n\n      delete this._responses[data.id]\n\n      if (data.data.error) {\n        response.reject(data.data.error)\n      } else {\n        response.resolve(data.data.result)\n      }\n    } else {\n      throw new Error(`Unknown type for SystemTestCommunicator: ${data.type}: ${JSON.stringify(data)}`)\n    }\n  }\n\n  onOpen = () => {\n    this.flushSendQueue()\n  }\n\n  /**\n   * @param {Record<string, any>} data\n   * @returns {void}\n   */\n  send(data) {\n    this._sendQueue.push(data)\n\n    if (this.ws.readyState == 1) {\n      this.flushSendQueue()\n    }\n  }\n\n  /**\n   * Sends a command and returns a promise that resolves with the response.\n   * @param {Record<string, any>} data - The command data to send.\n   * @returns {Promise<void>} A promise that resolves with the response data.\n   */\n  sendCommand(data) {\n    return new Promise((resolve, reject) => {\n      const id = this._sendQueueCount\n\n      this._sendQueueCount += 1\n      this._responses[id] = {resolve, reject}\n\n      this.send({type: \"command\", id, data})\n    })\n  }\n\n  /**\n   * @param {number} id\n   * @param {Record<string, any>} data\n   * @returns {void}\n   */\n  respond(id, data) {\n    this.send({type: \"response\", id, data})\n  }\n}\n"]}

package/build/system-test-http-server.js

@@ -0,0 +1,66 @@
+// @ts-check
+import fs from "node:fs/promises";
+import http from "node:http";
+import mime from "mime";
+import url from "url";
+export default class SystemTestHttpServer {
+    constructor() {
+        /**
+         * @param {http.IncomingMessage} request
+         * @param {http.ServerResponse} response
+         * @returns {Promise<void>}
+         */
+        this.onHttpServerRequest = async (request, response) => {
+            if (!request.url) {
+                response.statusCode = 400;
+                response.end("Bad Request");
+                return;
+            }
+            const parsedUrl = url.parse(request.url);
+            let filePath = `${process.cwd()}/dist${parsedUrl.pathname}`;
+            if (filePath.endsWith("/")) {
+                filePath += "index.html";
+            }
+            let fileExists;
+            try {
+                await fs.stat(filePath);
+                fileExists = true;
+            }
+            catch (_error) { // eslint-disable-line no-unused-vars
+                fileExists = false;
+            }
+            if (!fileExists) {
+                filePath = `${process.cwd()}/dist/index.html`;
+            }
+            const fileContent = await fs.readFile(filePath);
+            const mimeType = mime.getType(filePath);
+            response.statusCode = 200;
+            if (mimeType) {
+                response.setHeader("Content-Type", mimeType);
+            }
+            response.end(fileContent);
+        };
+    }
+    /** @returns {void} */
+    close() {
+        if (!this.httpServer) {
+            throw new Error("HTTP server is not initialized");
+        }
+        this.httpServer.close();
+    }
+    /** @returns {Promise<void>} */
+    async start() {
+        this.basePath = await fs.realpath(`${__dirname}/../..`);
+        await this.startHttpServer();
+    }
+    /** @returns {Promise<void>} */
+    startHttpServer() {
+        return new Promise((resolve) => {
+            this.httpServer = http.createServer(this.onHttpServerRequest);
+            this.httpServer.listen(1984, "localhost", () => {
+                resolve();
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{dist → build}/system-test.d.ts

@@ -34,6 +34,7 @@ export default class SystemTest {
     _started: boolean;
     _driverTimeouts: number;
     _timeouts: number;
+    /** @returns {SystemTestCommunicator} */
     getCommunicator(): SystemTestCommunicator;
     _host: string;
     _port: number;
@@ -45,9 +46,7 @@ export default class SystemTest {
      * @returns {string | undefined}
      */
     getBaseSelector(): string | undefined;
-    /**
-     * @returns {import("selenium-webdriver").WebDriver}
-     */
+    /** @returns {import("selenium-webdriver").WebDriver} */
     getDriver(): import("selenium-webdriver").WebDriver;
     /**
      * Sets the base selector for scoping element searches
@@ -76,7 +75,7 @@ export default class SystemTest {
     /**
      * Finds all elements by CSS selector
      * @param {string} selector
-     * @param {object} args
+     * @param {object} [args]
      * @param {number} [args.timeout]
      * @param {boolean} [args.visible]
      * @param {boolean} [args.useBaseSelector]
@@ -96,17 +95,17 @@ export default class SystemTest {
     /**
      * Finds a single element by CSS selector
      * @param {string} selector
-     * @param {object} args
+     * @param {object} [args]
      * @returns {Promise<import("selenium-webdriver").WebElement>}
      */
     find(selector: string, args?: object): Promise<import("selenium-webdriver").WebElement>;
     /**
      * Finds a single element by test ID
      * @param {string} testID
-     * @param {object} args
+     * @param {object} [args]
      * @returns {Promise<import("selenium-webdriver").WebElement>}
      */
-    findByTestID(testID: string, args: object): Promise<import("selenium-webdriver").WebElement>;
+    findByTestID(testID: string, args?: object): Promise<import("selenium-webdriver").WebElement>;
     /**
      * @param {string|import("selenium-webdriver").WebElement} elementOrIdentifier
      * @returns {Promise<import("selenium-webdriver").WebElement>}
@@ -124,20 +123,16 @@ export default class SystemTest {
      * @returns {Promise<string[]>}
      */
     getBrowserLogs(): Promise<string[]>;
-    /**
-     * @returns {Promise<string>}
-     */
+    /** @returns {Promise<string>} */
     getCurrentUrl(): Promise<string>;
-    /**
-     * @returns {number}
-     */
+    /** @returns {number} */
     getTimeouts(): number;
     /**
      * Interacts with an element by calling a method on it with the given arguments.
      * Retrying on ElementNotInteractableError.
-     * @param {import("selenium-webdriver").WebElement|string} elementOrIdentifier - The element or a CSS selector to find the element.
-     * @param {string} methodName - The method name to call on the element.
-     * @param {...any} args - Arguments to pass to the method.
+     * @param {import("selenium-webdriver").WebElement|string} elementOrIdentifier The element or a CSS selector to find the element.
+     * @param {string} methodName The method name to call on the element.
+     * @param {...any} args Arguments to pass to the method.
      * @returns {Promise<any>}
      */
     interact(elementOrIdentifier: import("selenium-webdriver").WebElement | string, methodName: string, ...args: any[]): Promise<any>;
@@ -149,11 +144,11 @@ export default class SystemTest {
     expectNoElement(selector: string): Promise<void>;
     /**
      * @param {string} selector
-     * @param {object} args
+     * @param {object} [args]
      * @param {boolean} [args.useBaseSelector]
      * @returns {Promise<void>}
      */
-    waitForNoSelector(selector: string, args: {
+    waitForNoSelector(selector: string, args?: {
         useBaseSelector?: boolean;
     }): Promise<void>;
     /**
@@ -167,9 +162,7 @@ export default class SystemTest {
      * @returns {Promise<void>}
      */
     expectNotificationMessage(expectedNotificationMessage: string): Promise<void>;
-    /**
-     * @returns {Promise<void>}
-     */
+    /** @returns {Promise<void>} */
     dismissNotificationMessages(): Promise<void>;
     /**
      * Indicates whether the system test has been started
@@ -249,9 +242,7 @@ export default class SystemTest {
      */
     onWebSocketConnection: (ws: WebSocket) => Promise<void>;
     ws: WebSocket;
-    /**
-     * @returns {void}
-     */
+    /** @returns {void} */
     onWebSocketClose: () => void;
     /**
      * Handles an error reported from the browser