@ricsam/isolate-client 0.1.9 → 0.1.11

package/dist/mjs/connection.mjs

@@ -1,5 +1,6 @@
 // packages/isolate-client/src/connection.ts
 import { connect as netConnect } from "node:net";
+import path from "node:path";
 import {
   createFrameParser,
   buildFrame,
@@ -396,6 +397,10 @@ async function createRuntime(state, options = {}, namespaceId) {
     callbacks.custom = registerCustomFunctions(state, options.customFunctions);
   }
   let playwrightHandler;
+  const browserConsoleLogs = [];
+  const networkRequests = [];
+  const networkResponses = [];
+  const pageListenerCleanups = [];
   if (options.playwright) {
     playwrightHandler = createPlaywrightHandler(options.playwright.page, {
       timeout: options.playwright.timeout,
@@ -407,65 +412,67 @@ async function createRuntime(state, options = {}, namespaceId) {
       const result2 = await playwrightHandler(op);
       return JSON.stringify(result2);
     });
-    const hasOnEvent = !!options.playwright.onEvent;
-    const hasConsoleHandler = options.playwright.console && options.console?.onEntry;
-    let browserConsoleLogCallbackId;
-    if (hasOnEvent || hasConsoleHandler) {
-      browserConsoleLogCallbackId = registerEventCallback(state, (entry) => {
-        const browserEntry = entry;
-        if (options.playwright.onEvent) {
-          options.playwright.onEvent({
-            type: "browserConsoleLog",
-            level: browserEntry.level,
-            stdout: browserEntry.stdout,
-            timestamp: browserEntry.timestamp
-          });
-        }
-        if (options.playwright.console && options.console?.onEntry) {
-          options.console.onEntry({
-            type: "browserOutput",
-            level: browserEntry.level,
-            stdout: browserEntry.stdout,
-            timestamp: browserEntry.timestamp
-          });
-        }
-      });
-    }
-    let networkRequestCallbackId;
-    if (hasOnEvent) {
-      networkRequestCallbackId = registerEventCallback(state, (info) => {
-        const reqInfo = info;
+    const page = options.playwright.page;
+    const onConsole = (msg) => {
+      const entry = {
+        level: msg.type(),
+        stdout: msg.text(),
+        timestamp: Date.now()
+      };
+      browserConsoleLogs.push(entry);
+      if (options.playwright.onEvent) {
+        options.playwright.onEvent({
+          type: "browserConsoleLog",
+          ...entry
+        });
+      }
+      if (options.playwright.console && options.console?.onEntry) {
+        options.console.onEntry({
+          type: "browserOutput",
+          ...entry
+        });
+      } else if (options.playwright.console) {
+        const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
+        console.log(prefix, entry.stdout);
+      }
+    };
+    const onRequest = (request2) => {
+      const info = {
+        url: request2.url(),
+        method: request2.method(),
+        headers: request2.headers(),
+        timestamp: Date.now()
+      };
+      networkRequests.push(info);
+      if (options.playwright.onEvent) {
         options.playwright.onEvent({
           type: "networkRequest",
-          url: reqInfo.url,
-          method: reqInfo.method,
-          headers: reqInfo.headers,
-          postData: reqInfo.postData,
-          resourceType: reqInfo.resourceType,
-          timestamp: reqInfo.timestamp
+          ...info
         });
-      });
-    }
-    let networkResponseCallbackId;
-    if (hasOnEvent) {
-      networkResponseCallbackId = registerEventCallback(state, (info) => {
-        const resInfo = info;
+      }
+    };
+    const onResponse = (response) => {
+      const info = {
+        url: response.url(),
+        status: response.status(),
+        headers: response.headers(),
+        timestamp: Date.now()
+      };
+      networkResponses.push(info);
+      if (options.playwright.onEvent) {
         options.playwright.onEvent({
           type: "networkResponse",
-          url: resInfo.url,
-          status: resInfo.status,
-          statusText: resInfo.statusText,
-          headers: resInfo.headers,
-          timestamp: resInfo.timestamp
+          ...info
         });
-      });
-    }
+      }
+    };
+    page.on("console", onConsole);
+    page.on("request", onRequest);
+    page.on("response", onResponse);
+    pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse));
     callbacks.playwright = {
       handlerCallbackId,
-      console: options.playwright.console && !options.console?.onEntry,
-      onBrowserConsoleLogCallbackId: browserConsoleLogCallbackId,
-      onNetworkRequestCallbackId: networkRequestCallbackId,
-      onNetworkResponseCallbackId: networkResponseCallbackId
+      console: options.playwright.console && !options.console?.onEntry
     };
   }
   let testEnvironmentOption;
@@ -723,29 +730,23 @@ async function createRuntime(state, options = {}, namespaceId) {
     }
   };
   const playwrightHandle = {
-    async getCollectedData() {
+    getCollectedData() {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
       }
-      const reqId = state.nextRequestId++;
-      const req = {
-        type: MessageType.GET_COLLECTED_DATA,
-        requestId: reqId,
-        isolateId
+      return {
+        browserConsoleLogs: [...browserConsoleLogs],
+        networkRequests: [...networkRequests],
+        networkResponses: [...networkResponses]
       };
-      return sendRequest(state, req);
     },
-    async clearCollectedData() {
+    clearCollectedData() {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
       }
-      const reqId = state.nextRequestId++;
-      const req = {
-        type: MessageType.CLEAR_COLLECTED_DATA,
-        requestId: reqId,
-        isolateId
-      };
-      await sendRequest(state, req);
+      browserConsoleLogs.length = 0;
+      networkRequests.length = 0;
+      networkResponses.length = 0;
     }
   };
   return {
@@ -772,6 +773,9 @@ async function createRuntime(state, options = {}, namespaceId) {
       await sendRequest(state, req);
     },
     dispose: async () => {
+      for (const cleanup of pageListenerCleanups) {
+        cleanup();
+      }
       isolateWsCallbacks.delete(isolateId);
       const reqId = state.nextRequestId++;
       const req = {
@@ -874,15 +878,15 @@ function registerFsCallbacks(state, callbacks) {
   const registrations = {};
   if (callbacks.readFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      const result = await callbacks.readFile(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      const result = await callbacks.readFile(path2);
       return new Uint8Array(result);
     });
     registrations.readFile = { callbackId, name: "readFile", type: "async" };
   }
   if (callbacks.writeFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, data) => {
+    state.callbacks.set(callbackId, async (path2, data) => {
       let buffer;
       if (data instanceof Uint8Array) {
         buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -893,42 +897,42 @@ function registerFsCallbacks(state, callbacks) {
       } else {
         buffer = new ArrayBuffer(0);
       }
-      await callbacks.writeFile(path, buffer);
+      await callbacks.writeFile(path2, buffer);
     });
     registrations.writeFile = { callbackId, name: "writeFile", type: "async" };
   }
   if (callbacks.unlink) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.unlink(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.unlink(path2);
     });
     registrations.unlink = { callbackId, name: "unlink", type: "async" };
   }
   if (callbacks.readdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.readdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.readdir(path2);
     });
     registrations.readdir = { callbackId, name: "readdir", type: "async" };
   }
   if (callbacks.mkdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, options) => {
-      await callbacks.mkdir(path, options);
+    state.callbacks.set(callbackId, async (path2, options) => {
+      await callbacks.mkdir(path2, options);
     });
     registrations.mkdir = { callbackId, name: "mkdir", type: "async" };
   }
   if (callbacks.rmdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.rmdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.rmdir(path2);
     });
     registrations.rmdir = { callbackId, name: "rmdir", type: "async" };
   }
   if (callbacks.stat) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.stat(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.stat(path2);
     });
     registrations.stat = { callbackId, name: "stat", type: "async" };
   }
@@ -943,15 +947,13 @@ function registerFsCallbacks(state, callbacks) {
 }
 function registerModuleLoaderCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
-  state.callbacks.set(callbackId, async (moduleName) => {
+  state.callbacks.set(callbackId, async (moduleName, importer) => {
     const specifier = moduleName;
-    const cached = state.moduleSourceCache.get(specifier);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const source = await callback(specifier);
-    state.moduleSourceCache.set(specifier, source);
-    return source;
+    const importerInfo = importer;
+    const result = await callback(specifier, importerInfo);
+    const resolvedPath = path.posix.join(result.resolveDir, path.posix.basename(specifier));
+    state.moduleSourceCache.set(resolvedPath, result.code);
+    return result;
   });
   return { callbackId, name: "moduleLoader", type: "async" };
 }
@@ -1280,4 +1282,4 @@ export {
   connect
 };
 
-//# debugId=3C4C993A49BD89A964756E2164756E21
+//# debugId=9932655385124AD564756E2164756E21