@ricsam/isolate 0.1.12 → 0.1.14

package/dist/cjs/internal/event-callback.cjs

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/event-callback.ts
+var exports_event_callback = {};
+__export(exports_event_callback, {
+  invokeBestEffortEventHandler: () => invokeBestEffortEventHandler
+});
+module.exports = __toCommonJS(exports_event_callback);
+var warnedAsyncHandlers = new WeakSet;
+function isPromiseLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function invokeBestEffortEventHandler(label, handler, ...args) {
+  if (!handler) {
+    return;
+  }
+  try {
+    const result = handler(...args);
+    if (!isPromiseLike(result)) {
+      return;
+    }
+    if (!warnedAsyncHandlers.has(handler)) {
+      warnedAsyncHandlers.add(handler);
+      console.warn(`[isolate] ${label} handlers are sync-only and best-effort. Returned promises are ignored.`);
+    }
+    Promise.resolve(result).catch((error) => {
+      console.error(`[isolate] ${label} handler rejected after returning a promise.`, error);
+    });
+  } catch (error) {
+    console.error(`[isolate] ${label} handler failed.`, error);
+  }
+}
+
+//# debugId=8A87FF900221ECC164756E2164756E21

package/dist/cjs/internal/event-callback.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/event-callback.ts"],
+  "sourcesContent": [
+    "const warnedAsyncHandlers = new WeakSet<Function>();\n\nfunction isPromiseLike(value: unknown): value is PromiseLike<unknown> {\n  return (\n    value !== null &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    typeof (value as { then?: unknown }).then === \"function\"\n  );\n}\n\nexport function invokeBestEffortEventHandler<TArgs extends unknown[]>(\n  label: string,\n  handler: ((...args: TArgs) => unknown) | undefined,\n  ...args: TArgs\n): void {\n  if (!handler) {\n    return;\n  }\n\n  try {\n    const result = handler(...args);\n    if (!isPromiseLike(result)) {\n      return;\n    }\n\n    if (!warnedAsyncHandlers.has(handler)) {\n      warnedAsyncHandlers.add(handler);\n      console.warn(\n        `[isolate] ${label} handlers are sync-only and best-effort. Returned promises are ignored.`,\n      );\n    }\n\n    void Promise.resolve(result).catch((error) => {\n      console.error(\n        `[isolate] ${label} handler rejected after returning a promise.`,\n        error,\n      );\n    });\n  } catch (error) {\n    console.error(`[isolate] ${label} handler failed.`, error);\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAM,sBAAsB,IAAI;AAEhC,SAAS,aAAa,CAAC,OAA+C;AAAA,EACpE,OACE,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAA6B,SAAS;AAAA;AAI3C,SAAS,4BAAqD,CACnE,OACA,YACG,MACG;AAAA,EACN,IAAI,CAAC,SAAS;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,IAAI;AAAA,IACF,MAAM,SAAS,QAAQ,GAAG,IAAI;AAAA,IAC9B,IAAI,CAAC,cAAc,MAAM,GAAG;AAAA,MAC1B;AAAA,IACF;AAAA,IAEA,IAAI,CAAC,oBAAoB,IAAI,OAAO,GAAG;AAAA,MACrC,oBAAoB,IAAI,OAAO;AAAA,MAC/B,QAAQ,KACN,aAAa,8EACf;AAAA,IACF;AAAA,IAEK,QAAQ,QAAQ,MAAM,EAAE,MAAM,CAAC,UAAU;AAAA,MAC5C,QAAQ,MACN,aAAa,qDACb,KACF;AAAA,KACD;AAAA,IACD,OAAO,OAAO;AAAA,IACd,QAAQ,MAAM,aAAa,yBAAyB,KAAK;AAAA;AAAA;",
+  "debugId": "8A87FF900221ECC164756E2164756E21",
+  "names": []
+}

package/dist/cjs/internal/playwright/handler.cjs

@@ -50,6 +50,7 @@ __export(exports_handler, {
   createPlaywrightFactoryHandler: () => createPlaywrightFactoryHandler
 });
 module.exports = __toCommonJS(exports_handler);
+var import_event_callback = require("../event-callback.cjs");
 var import_types = require("./types.cjs");
 var INPUT_FILES_VALIDATION_ERROR = "setInputFiles() expects a file path string, an array of file path strings, " + "a single inline file object ({ name, mimeType, buffer }), or an array of inline file objects.";
 var MIXED_INPUT_FILES_ERROR = "setInputFiles() does not support mixing file paths and inline file objects in the same array.";
@@ -65,9 +66,7 @@ function cloneCollectedData(collectedData) {
 function createPlaywrightCollector(registry) {
   const emitEvent = (event) => {
     for (const callback of registry.eventSubscribers) {
-      try {
-        callback(event);
-      } catch {}
+      import_event_callback.invokeBestEffortEventHandler("playwright.onEvent", callback, event);
     }
   };
   const getRequestId = (request) => {
@@ -1686,4 +1685,4 @@ function getDefaultPlaywrightHandlerMetadata(handler) {
   return handler[import_types.DEFAULT_PLAYWRIGHT_HANDLER_META];
 }
 
-//# debugId=1E1ED47A7B37F25964756E2164756E21
+//# debugId=79FCFD3DA3FC301B64756E2164756E21