@lvce-editor/test-with-playwright-worker 22.36.2 → 22.36.4

package/dist/workerMain.js

@@ -1198,6 +1198,162 @@ const get = id => {
   return rpcs[id];
 };
 
+// This function is serialized by Playwright and must not close over module bindings.
+const install = () => {
+  const limit = 5000;
+  const payloadLimit = 8192;
+  const entries = [];
+  let sequence = 0;
+  const channels = new WeakMap();
+  let nextChannel = 0;
+  const originalAdd = Object.getOwnPropertyDescriptor(EventTarget.prototype, 'addEventListener').value;
+  const record = (kind, data) => {
+    const entry = {
+      ...data,
+      kind,
+      sequence: sequence++,
+      timestamp: performance.now()
+    };
+    entries[entry.sequence % limit] = entry;
+  };
+  const describe = target => {
+    if (!(target instanceof Element)) {
+      if (!(target instanceof Node)) return 'unknown';
+      return `${target.nodeName}:${target.nodeValue || ''}`.slice(0, 200);
+    }
+    return `${target.tagName}#${target.id}.${target.getAttribute('class') || ''}`.slice(0, 200);
+  };
+  const serialize = value => {
+    let truncated = false;
+    const seen = new WeakSet();
+    try {
+      const text = JSON.stringify(value, (_key, item) => {
+        if (typeof item === 'bigint') return `${item}n`;
+        if (typeof item === 'string') {
+          truncated ||= item.length > 2048;
+          return item.slice(0, 2048);
+        }
+        if (typeof item !== 'object' || item === null) return item;
+        if (seen.has(item)) return '[Circular]';
+        seen.add(item);
+        if (item instanceof MessagePort) return '[MessagePort]';
+        if (item instanceof ArrayBuffer) return `[ArrayBuffer ${item.byteLength}]`;
+        if (ArrayBuffer.isView(item)) return `[${item.constructor.name} ${item.byteLength}]`;
+        return item;
+      }) || '';
+      return {
+        payload: text.slice(0, payloadLimit),
+        truncated: truncated || text.length > payloadLimit
+      };
+    } catch {
+      return {
+        payload: '[Unserializable]',
+        truncated: true
+      };
+    }
+  };
+  const observe = target => {
+    const existing = channels.get(target);
+    if (existing !== undefined) return existing;
+    const channel = nextChannel++;
+    channels.set(target, channel);
+    Reflect.apply(originalAdd, target, ['message', event => {
+      record('rpc-received', {
+        channel,
+        ...serialize(event.data)
+      });
+    }]);
+    return channel;
+  };
+  class EventHooks {
+    addEventListener(...args) {
+      if (args[0] === 'message' && (this instanceof MessagePort || this instanceof Worker)) observe(this);
+      return Reflect.apply(originalAdd, this, args);
+    }
+  }
+  Object.defineProperty(EventTarget.prototype, 'addEventListener', {
+    ...Object.getOwnPropertyDescriptor(EventTarget.prototype, 'addEventListener'),
+    value: Object.getOwnPropertyDescriptor(EventHooks.prototype, 'addEventListener').value
+  });
+  for (const prototype of [MessagePort.prototype, Worker.prototype]) {
+    const postDescriptor = Object.getOwnPropertyDescriptor(prototype, 'postMessage');
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'onmessage');
+    const originalSet = Object.getOwnPropertyDescriptor(descriptor, 'set').value;
+    class PortHooks {
+      postMessage(...args) {
+        const channel = observe(this);
+        const data = serialize(args[0]);
+        const result = Reflect.apply(postDescriptor.value, this, args);
+        record('rpc-sent', {
+          channel,
+          ...data
+        });
+        return result;
+      }
+      set onmessage(listener) {
+        observe(this);
+        Reflect.apply(originalSet, this, [listener]);
+      }
+    }
+    const hookDescriptor = Object.getOwnPropertyDescriptor(PortHooks.prototype, 'onmessage');
+    Object.defineProperties(prototype, {
+      onmessage: {
+        ...descriptor,
+        set: Object.getOwnPropertyDescriptor(hookDescriptor, 'set').value
+      },
+      postMessage: {
+        ...postDescriptor,
+        value: Object.getOwnPropertyDescriptor(PortHooks.prototype, 'postMessage').value
+      }
+    });
+  }
+  for (const type of ['click', 'input', 'keydown', 'keyup', 'pointerdown', 'pointerup', 'pointerover', 'pointerout', 'focusin', 'focusout']) {
+    document.addEventListener(type, event => {
+      record('input', {
+        event: type,
+        key: event.key,
+        target: describe(event.target),
+        trusted: event.isTrusted
+      });
+    }, {
+      capture: true,
+      passive: true
+    });
+  }
+  const observer = new MutationObserver(mutations => {
+    record('dom-mutation', {
+      changes: mutations.slice(0, 10).map(mutation => ({
+        added: [...mutation.addedNodes].slice(0, 2).map(describe),
+        addedCount: mutation.addedNodes.length,
+        attribute: mutation.attributeName,
+        removed: [...mutation.removedNodes].slice(0, 2).map(describe),
+        removedCount: mutation.removedNodes.length,
+        target: describe(mutation.target),
+        type: mutation.type,
+        value: mutation.attributeName && mutation.target instanceof Element ? mutation.target.getAttribute(mutation.attributeName)?.slice(0, 200) : undefined
+      })),
+      count: mutations.length
+    });
+  });
+  observer.observe(document, {
+    attributes: true,
+    characterData: true,
+    childList: true,
+    subtree: true
+  });
+  Object.defineProperty(globalThis, '__lvceTraceTimeline', {
+    value: () => {
+      const offset = sequence > limit ? sequence % limit : 0;
+      return {
+        dropped: Math.max(0, sequence - limit),
+        entries: [...entries.slice(offset), ...entries.slice(0, offset)],
+        limit,
+        version: 1
+      };
+    }
+  });
+};
+
 const HandleResult = 'HandleResult';
 const HandleFinalResult = 'HandleFinalResult';
 
@@ -1268,19 +1424,26 @@ const exportTrace = async ({
   page,
   test
 }) => {
-  let text;
+  let capture;
   try {
-    text = await page.evaluate(traceSelector => {
-      return globalThis.document.querySelector(traceSelector)?.textContent || undefined;
+    capture = await page.evaluate(traceSelector => {
+      return {
+        text: globalThis.document.querySelector(traceSelector)?.textContent || undefined,
+        timeline: globalThis.__lvceTraceTimeline?.()
+      };
     }, selector);
   } catch {
     return false;
   }
-  if (!text) {
+  if (!capture.text && !capture.timeline) {
     return false;
   }
-  JSON.parse(text);
-  await writeFile(join(directory, getFileName(test)), `${text}\n`);
+  const trace = capture.text ? JSON.parse(capture.text) : {
+    entries: [],
+    version: 1
+  };
+  if (capture.timeline) trace.timeline = capture.timeline;
+  await writeFile(join(directory, getFileName(test)), `${JSON.stringify(trace)}\n`);
   return true;
 };
 
@@ -1869,7 +2032,7 @@ const runTestsWithReusedPage = async ({
     const url = getAllTestsUrl(port, filter, traceFocus ?? false, rendererWorkerTraceDirectory !== undefined);
     await page.goto(url, {
       timeout,
-      waitUntil: 'networkidle'
+      waitUntil: 'domcontentloaded'
     });
     const text = await readTestResultsText(page, timeout);
     results = parseTestResults(text);
@@ -2472,6 +2635,9 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     testPath
   });
   try {
+    if (traceRendererWorker) {
+      await page.addInitScript(install);
+    }
     if (reusePage) {
       await runWithJavascriptCoverage({
         coverage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-with-playwright-worker",
-  "version": "22.36.2",
+  "version": "22.36.4",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",