@lvce-editor/test-with-playwright-worker 22.36.1 → 22.36.3

package/dist/coverageWorkerMain.js

@@ -460,6 +460,9 @@ const restoreExistingError = (error, currentStack) => {
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
+  Object.assign(restoredError, {
+    code: error.code
+  });
   const parentStack = getParentStack(error);
   setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
@@ -479,9 +482,13 @@ const applyDataProperties = (restoredError, error) => {
     // @ts-ignore
     restoredError.codeFrame = error.data.codeFrame;
   }
-  if (error.data.code) {
+  if (typeof error.data.code === 'string' || typeof error.data.code === 'number') {
     // @ts-ignore
-    restoredError.code = error.data.code;
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.data.code,
+      writable: true
+    });
   }
   if (error.data.type) {
     // @ts-ignore
@@ -503,6 +510,13 @@ const applyDirectProperties = (restoredError, error) => {
 };
 const restoreMessageError = (error, _currentStack) => {
   const restoredError = constructError(error.message, error.type, error.name);
+  if (typeof error.code === 'string' || typeof error.code === 'number') {
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.code,
+      writable: true
+    });
+  }
   if (error.data) {
     applyDataProperties(restoredError, error);
   } else {
@@ -581,7 +595,7 @@ const getErrorProperty = (error, prettyError) => {
   return {
     code: Custom,
     data: {
-      code: prettyError.code,
+      code: prettyError.code ?? error?.code,
       codeFrame: prettyError.codeFrame,
       name: prettyError.name,
       stack: getStack(prettyError),
@@ -618,7 +632,12 @@ const getErrorResponseSimple = (id, error) => {
   return {
     error: {
       code: Custom,
-      data: error,
+      data: error instanceof Error ? {
+        ...error,
+        code: 'code' in error ? error.code : undefined,
+        stack: error.stack,
+        type: error.name
+      } : error,
       // @ts-ignore
       message: error.message
     },

package/dist/workerMain.js

@@ -721,6 +721,9 @@ const restoreExistingError = (error, currentStack) => {
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
+  Object.assign(restoredError, {
+    code: error.code
+  });
   const parentStack = getParentStack(error);
   setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
@@ -740,9 +743,13 @@ const applyDataProperties = (restoredError, error) => {
     // @ts-ignore
     restoredError.codeFrame = error.data.codeFrame;
   }
-  if (error.data.code) {
+  if (typeof error.data.code === 'string' || typeof error.data.code === 'number') {
     // @ts-ignore
-    restoredError.code = error.data.code;
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.data.code,
+      writable: true
+    });
   }
   if (error.data.type) {
     // @ts-ignore
@@ -764,6 +771,13 @@ const applyDirectProperties = (restoredError, error) => {
 };
 const restoreMessageError = (error, _currentStack) => {
   const restoredError = constructError(error.message, error.type, error.name);
+  if (typeof error.code === 'string' || typeof error.code === 'number') {
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.code,
+      writable: true
+    });
+  }
   if (error.data) {
     applyDataProperties(restoredError, error);
   } else {
@@ -842,7 +856,7 @@ const getErrorProperty = (error, prettyError) => {
   return {
     code: Custom,
     data: {
-      code: prettyError.code,
+      code: prettyError.code ?? error?.code,
       codeFrame: prettyError.codeFrame,
       name: prettyError.name,
       stack: getStack(prettyError),
@@ -879,7 +893,12 @@ const getErrorResponseSimple = (id, error) => {
   return {
     error: {
       code: Custom,
-      data: error,
+      data: error instanceof Error ? {
+        ...error,
+        code: 'code' in error ? error.code : undefined,
+        stack: error.stack,
+        type: error.name
+      } : error,
       // @ts-ignore
       message: error.message
     },
@@ -1179,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';
 
@@ -1249,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;
 };
 
@@ -2210,10 +2392,14 @@ const getElectronLaunchOptions = ({
   args,
   env,
   executablePath
-}) => {
+}, profileRoot) => {
   const launchEnv = {
     ...getProcessEnv(),
-    ...env
+    ...env,
+    XDG_CACHE_HOME: join(profileRoot, 'cache'),
+    XDG_CONFIG_HOME: join(profileRoot, 'config'),
+    XDG_DATA_HOME: join(profileRoot, 'data'),
+    XDG_STATE_HOME: join(profileRoot, 'state')
   };
   delete launchEnv['ELECTRON_RUN_AS_NODE'];
   return {
@@ -2252,19 +2438,19 @@ const createElectronLaunch = ({
   signal,
   userDataDir
 }) => {
-  let disposed = false;
-  const dispose = async () => {
-    if (disposed) {
-      return;
+  let disposal;
+  const dispose = () => {
+    if (disposal) {
+      return disposal;
     }
-    disposed = true;
     signal.removeEventListener('abort', handleAbort);
     process.off('SIGINT', handleSigint);
     process.off('SIGTERM', handleSigterm);
-    await closeElectron({
+    disposal = closeElectron({
       electronApp,
       userDataDir
     });
+    return disposal;
   };
   const handleAbort = () => {
     void dispose();
@@ -2297,14 +2483,15 @@ const startElectron = async ({
   runtimeOptions,
   signal
 }) => {
-  const launchOptions = getElectronLaunchOptions(runtimeOptions);
   const userDataDir = await mkdtemp(join(tmpdir(), 'test-with-playwright-electron-'));
-  const args = getElectronProcessArgs({
-    args: launchOptions.args,
-    userDataDir
-  });
   let electronApp;
   try {
+    signal.throwIfAborted();
+    const launchOptions = getElectronLaunchOptions(runtimeOptions, userDataDir);
+    const args = getElectronProcessArgs({
+      args: launchOptions.args,
+      userDataDir
+    });
     const {
       _electron
     } = await import('@playwright/test');
@@ -2314,9 +2501,11 @@ const startElectron = async ({
       executablePath: launchOptions.executablePath,
       timeout: electronLaunchTimeout
     });
+    signal.throwIfAborted();
     const page = await electronApp.firstWindow({
       timeout: electronLaunchTimeout
     });
+    signal.throwIfAborted();
     return createElectronLaunch({
       electronApp,
       page,
@@ -2446,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.1",
+  "version": "22.36.3",
   "description": "Worker package for test-with-playwright",
   "repository": {
     "type": "git",