@lvce-editor/test-with-playwright-worker 22.12.1 → 22.13.1

package/dist/svgScreenshot.js

@@ -215,6 +215,10 @@ var SvgScreenshot = (function (exports) {
 		// correctly by all compliant CSS consumers.
 		const STYLE_TAG = /(<)(\/?style\b)/gi;
 		const COMMENT_OPEN = /(<)(!--)/g;
+
+		// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
+		// Params starting with anything else need a space to stay separate tokens.
+		const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
 		function escapeHTMLInCSS(str) {
 		  if (typeof str !== 'string') return str;
 		  if (!str.includes('<')) return str;
@@ -240,12 +244,13 @@ var SvgScreenshot = (function (exports) {
 		function atruleStart(str, node) {
 		  let name = '@' + node.name;
 		  let params = node.params ? str.rawValue(node, 'params') : '';
-		  if (typeof node.raws.afterName !== 'undefined') {
-		    name += node.raws.afterName;
-		  } else if (params) {
-		    name += ' ';
+		  let afterName = node.raws.afterName;
+		  if (typeof afterName === 'undefined') {
+		    afterName = params ? ' ' : '';
+		  } else if (afterName === '' && params && !AT_NAME_END.test(params[0])) {
+		    afterName = ' ';
 		  }
-		  return name + params;
+		  return name + afterName + params;
 		}
 		function pushBody(str, stack, node) {
 		  let nodes = node.nodes;
@@ -257,10 +262,19 @@ var SvgScreenshot = (function (exports) {
 		  let semicolon = str.raw(node, 'semicolon');
 		  let isDocument = node.type === 'document';
 		  for (let i = nodes.length - 1; i >= 0; i--) {
+		    let child = nodes[i];
+		    let childSemicolon = last !== i || semicolon;
+		    // A childless at-rule or a custom property declaration that still has
+		    // following siblings must be terminated. Without the semicolon those
+		    // trailing comments are folded into the at-rule's prelude or the custom
+		    // property's value and disappear when the output is re-parsed.
+		    if (!childSemicolon && i < nodes.length - 1 && (child.type === 'atrule' && !child.nodes || child.type === 'decl' && child.prop.startsWith('--'))) {
+		      childSemicolon = true;
+		    }
 		    stack.push({
 		      document: isDocument,
-		      node: nodes[i],
-		      semicolon: last !== i || semicolon
+		      node: child,
+		      semicolon: childSemicolon
 		    });
 		  }
 		}
@@ -1724,15 +1738,12 @@ var SvgScreenshot = (function (exports) {
 		  }
 		  loadFile(path, cssFile, trusted) {
 		    if (!trusted && !this.unsafeMap) {
-		      if (!/\.map$/i.test(path)) {
+		      if (!/\.map$/i.test(path)) return undefined;
+		      if (!cssFile) return undefined;
+		      let rel = relative(dirname(cssFile), path);
+		      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
 		        return undefined;
 		      }
-		      if (cssFile) {
-		        let relativePath = relative(dirname(cssFile), path);
-		        if (relativePath === '..' || relativePath.startsWith('..' + sep) || isAbsolute(relativePath)) {
-		          return undefined;
-		        }
-		      }
 		    }
 		    this.root = dirname(path);
 		    if (existsSync(path)) {
@@ -3493,11 +3504,22 @@ var SvgScreenshot = (function (exports) {
 		if (hasRequiredWarning) return warning;
 		hasRequiredWarning = 1;
 
+		let Container = requireContainer();
+		let {
+		  my
+		} = requireSymbols();
 		class Warning {
 		  constructor(text, opts = {}) {
 		    this.type = 'warning';
 		    this.text = text;
 		    if (opts.node && opts.node.source) {
+		      if (!opts.node[my]) {
+		        // The node comes from another PostCSS copy in node_modules, so it does
+		        // not have this copy’s methods. Container#normalize() rebuilds such
+		        // nodes on insert, but a node passed straight to Result#warn() never
+		        // goes through it.
+		        Container.rebuild(opts.node);
+		      }
 		      let range = opts.node.rangeBy(opts);
 		      this.line = range.start.line;
 		      this.column = range.start.column;
@@ -4242,7 +4264,7 @@ var SvgScreenshot = (function (exports) {
 		let Root = requireRoot();
 		class Processor {
 		  constructor(plugins = []) {
-		    this.version = '8.5.19';
+		    this.version = '8.5.23';
 		    this.plugins = this.normalize(plugins);
 		  }
 		  normalize(plugins) {

package/dist/workerMain.js

@@ -1,5 +1,5 @@
-import { join, dirname, basename } from 'node:path';
-import { readFile, writeFile, readdir, mkdir, rm, access, mkdtemp } from 'node:fs/promises';
+import { join, dirname, basename, extname } from 'node:path';
+import { readFile, writeFile, readdir, rm, mkdir, access, mkdtemp } from 'node:fs/promises';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import IstanbulCoverage from 'istanbul-lib-coverage';
 import v8ToIstanbul from 'v8-to-istanbul';
@@ -514,7 +514,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -545,31 +548,45 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
 const restoreExistingError = (error, currentStack) => {
   if (typeof error.stack === 'string') {
-    error.stack = error.stack + NewLine + currentStack;
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
   }
   return error;
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
   const parentStack = getParentStack(error);
-  restoredError.stack = parentStack + NewLine + currentStack;
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
 };
 const restoreStackFromData = (restoredError, error, currentStack) => {
   if (error.data.stack && error.data.type && error.message) {
-    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
     return;
   }
   if (error.data.stack) {
-    restoredError.stack = error.data.stack;
+    setStack(restoredError, error.data.stack);
   }
 };
 const applyDataProperties = (restoredError, error) => {
-  if (!error.data) {
-    return;
-  }
   restoreStackFromData(restoredError, error, getCurrentStack());
   if (error.data.codeFrame) {
     // @ts-ignore
@@ -590,7 +607,7 @@ const applyDirectProperties = (restoredError, error) => {
     const indexNewLine = getNewLineIndex(lowerStack);
     const parentStack = getParentStack(error);
     // @ts-ignore
-    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
   }
   if (error.codeFrame) {
     // @ts-ignore
@@ -989,6 +1006,41 @@ const getTests = async testSrc => {
   }
 };
 
+const selector = 'script.RendererWorkerTrace';
+const getFileName = test => {
+  const name = basename(test);
+  return `${name.slice(0, -extname(name).length)}.json`;
+};
+const prepareDirectory = async directory => {
+  await rm(directory, {
+    force: true,
+    recursive: true
+  });
+  await mkdir(directory, {
+    recursive: true
+  });
+};
+const exportTrace = async ({
+  directory,
+  page,
+  test
+}) => {
+  let text;
+  try {
+    text = await page.evaluate(traceSelector => {
+      return globalThis.document.querySelector(traceSelector)?.textContent || undefined;
+    }, selector);
+  } catch {
+    return false;
+  }
+  if (!text) {
+    return false;
+  }
+  JSON.parse(text);
+  await writeFile(join(directory, getFileName(test)), `${text}\n`);
+  return true;
+};
+
 const Cli = 6001;
 
 const browserScriptCache = {};
@@ -1267,14 +1319,22 @@ const getTestState = (testOverlayState, text) => {
  * @param {number} port
  * @param {boolean} traceFocus
  */
-const getUrlFromTestFile = (absolutePath, port, traceFocus) => {
+const getUrlFromTestFile = (absolutePath, port, traceFocus, traceRendererWorker) => {
   const baseName = basename(absolutePath);
   const htmlFileName = baseName.slice(0, -'.js'.length) + '.html';
-  const baseUrl = `http://localhost:${port}/tests/${htmlFileName}`;
+  const url = new URL(`http://localhost:${port}/tests/${htmlFileName}`);
   if (traceFocus) {
-    return `${baseUrl}?traceFocus=true`;
+    url.searchParams.set('traceFocus', 'true');
+  }
+  if (traceRendererWorker) {
+    url.searchParams.set('traceRendererWorker', 'true');
   }
-  return baseUrl;
+  return url.href;
+};
+const navigateToTest = async (page, url) => {
+  await page.goto(url, {
+    waitUntil: 'domcontentloaded'
+  });
 };
 const runTest = async ({
   page,
@@ -1283,17 +1343,16 @@ const runTest = async ({
   test,
   testSrc,
   timeout,
-  traceFocus
+  traceFocus,
+  traceRendererWorker
 }) => {
   const start = performance.now();
   try {
     const {
       expect
     } = await import('@playwright/test');
-    const url = getUrlFromTestFile(test, port, traceFocus);
-    await page.goto(url, {
-      waitUntil: 'networkidle'
-    });
+    const url = getUrlFromTestFile(test, port, traceFocus ?? false, traceRendererWorker ?? false);
+    await navigateToTest(page, url);
     const testOverlay = page.locator('#TestOverlay');
     await expect(testOverlay).toBeVisible({
       timeout
@@ -1371,6 +1430,7 @@ const runTests = async ({
   onResult,
   page,
   port,
+  rendererWorkerTraceDirectory,
   svgScreenshotOptions,
   tests,
   testSrc,
@@ -1391,10 +1451,18 @@ const runTests = async ({
       testSrc,
       timeout,
       traceFocus: traceFocus ?? false,
+      traceRendererWorker: rendererWorkerTraceDirectory !== undefined,
       ...(svgScreenshotOptions && {
         svgScreenshotOptions
       })
     });
+    if (rendererWorkerTraceDirectory) {
+      await exportTrace({
+        directory: rendererWorkerTraceDirectory,
+        page,
+        test
+      });
+    }
     await onResult(result);
     // @ts-ignore
     const resultCounts = getResultCounts$1(result.status);
@@ -1441,11 +1509,14 @@ const getResultCounts = status => {
       };
   }
 };
-const getAllTestsUrl = (port, filter, traceFocus) => {
+const getAllTestsUrl = (port, filter, traceFocus, traceRendererWorker) => {
   const url = new URL(`http://localhost:${port}/tests/_all.html`);
   if (traceFocus) {
     url.searchParams.set('traceFocus', 'true');
   }
+  if (traceRendererWorker) {
+    url.searchParams.set('traceRendererWorker', 'true');
+  }
   if (filter) {
     url.searchParams.set('filter', filter);
   }
@@ -1538,13 +1609,14 @@ const runTestsWithReusedPage = async ({
   onResult,
   page,
   port,
+  rendererWorkerTraceDirectory,
   timeout,
   traceFocus
 }) => {
   const start = performance.now();
   let results;
   try {
-    const url = getAllTestsUrl(port, filter, traceFocus ?? false);
+    const url = getAllTestsUrl(port, filter, traceFocus ?? false, rendererWorkerTraceDirectory !== undefined);
     await page.goto(url, {
       timeout,
       waitUntil: 'networkidle'
@@ -1554,6 +1626,13 @@ const runTestsWithReusedPage = async ({
   } catch (error) {
     results = [getFailedAllTestsResult(error, start)];
   }
+  if (rendererWorkerTraceDirectory) {
+    await exportTrace({
+      directory: rendererWorkerTraceDirectory,
+      page,
+      test: '_all.html'
+    });
+  }
   let failed = 0;
   let passed = 0;
   let skipped = 0;
@@ -1803,7 +1882,7 @@ const getPort = () => {
 };
 
 const getPossibleServerPaths = cwd => {
-  const toTry = ['@lvce-editor/server', pathToFileURL(join(cwd, '..', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(), pathToFileURL(join(cwd, '..', 'build', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(), pathToFileURL(join(cwd, '..', '..', '..', 'packages', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString()];
+  const toTry = ['@lvce-editor/server', pathToFileURL(join(cwd, '..', '..', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(), pathToFileURL(join(cwd, '..', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(), pathToFileURL(join(cwd, '..', 'build', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString(), pathToFileURL(join(cwd, '..', '..', '..', 'packages', 'server', 'node_modules', '@lvce-editor', 'server', 'index.js')).toString()];
   return toTry;
 };
 
@@ -2117,8 +2196,9 @@ const tearDownTests = async ({
  * @param {string} filter
  * @param {boolean} reusePage
  * @param {boolean} coverage
+ * @param {boolean} traceRendererWorker
  */
-const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage, svgScreenshotOptions, coverage) => {
+const runAllTests = async (extensionPath, testPath, cwd, browser, headless, timeout, runtimeOptions, traceFocus, filter, reusePage, svgScreenshotOptions, coverage, traceRendererWorker) => {
   string(extensionPath);
   string(testPath);
   string(cwd);
@@ -2128,6 +2208,7 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
   object(runtimeOptions);
   boolean(reusePage);
   boolean(coverage);
+  boolean(traceRendererWorker);
   if (svgScreenshotOptions !== undefined) {
     object(svgScreenshotOptions);
   }
@@ -2137,6 +2218,10 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
     signal
   } = controller;
   const testSrc = join(testPath, 'src');
+  const rendererWorkerTraceDirectory = join(cwd, 'renderer-worker-traces');
+  if (traceRendererWorker) {
+    await prepareDirectory(rendererWorkerTraceDirectory);
+  }
   const onResult = async result => {
     await rpc.invoke(HandleResult, result);
   };
@@ -2202,7 +2287,10 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
             page,
             port,
             timeout,
-            traceFocus
+            traceFocus,
+            ...(traceRendererWorker && {
+              rendererWorkerTraceDirectory
+            })
           });
         }
       });
@@ -2225,6 +2313,9 @@ const runAllTests = async (extensionPath, testPath, cwd, browser, headless, time
           testSrc,
           timeout,
           traceFocus,
+          ...(traceRendererWorker && {
+            rendererWorkerTraceDirectory
+          }),
           ...(svgScreenshotOptions && {
             svgScreenshotOptions
           })

package/package.json

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