@percy/core 1.12.0 → 1.14.0

package/dist/discovery.js

@@ -1,23 +1,24 @@
 import logger from '@percy/logger';
 import Queue from './queue.js';
-import { normalizeURL, hostnameMatches, createRootResource, createPercyCSSResource, createLogResource, yieldAll } from './utils.js'; // Logs verbose debug logs detailing various snapshot options.
+import { normalizeURL, hostnameMatches, createRootResource, createPercyCSSResource, createLogResource, yieldAll } from './utils.js';
 
+// Logs verbose debug logs detailing various snapshot options.
 function debugSnapshotOptions(snapshot) {
-  let log = logger('core:snapshot'); // log snapshot info
+  let log = logger('core:snapshot');
 
+  // log snapshot info
   log.debug('---------', snapshot.meta);
-  log.debug(`Received snapshot: ${snapshot.name}`, snapshot.meta); // will log debug info for an object property if its value is defined
+  log.debug(`Received snapshot: ${snapshot.name}`, snapshot.meta);
 
+  // will log debug info for an object property if its value is defined
   let debugProp = (obj, prop, format = String) => {
     let val = prop.split('.').reduce((o, k) => o === null || o === void 0 ? void 0 : o[k], obj);
-
     if (val != null) {
       // join formatted array values with a space
       val = [].concat(val).map(format).join(', ');
       log.debug(`- ${prop}: ${val}`, snapshot.meta);
     }
   };
-
   debugProp(snapshot, 'url');
   debugProp(snapshot, 'scope');
   debugProp(snapshot, 'widths', v => `${v}px`);
@@ -39,65 +40,62 @@ function debugSnapshotOptions(snapshot) {
   debugProp(snapshot, 'clientInfo');
   debugProp(snapshot, 'environmentInfo');
   debugProp(snapshot, 'domSnapshot', Boolean);
-
   for (let added of snapshot.additionalSnapshots || []) {
     log.debug(`Additional snapshot: ${added.name}`, snapshot.meta);
     debugProp(added, 'waitForTimeout');
     debugProp(added, 'waitForSelector');
     debugProp(added, 'execute');
   }
-} // Wait for a page's asset discovery network to idle
-
+}
 
+// Wait for a page's asset discovery network to idle
 function waitForDiscoveryNetworkIdle(page, options) {
   let {
     allowedHostnames,
     networkIdleTimeout
   } = options;
-
   let filter = r => hostnameMatches(allowedHostnames, r.url);
-
   return page.network.idle(filter, networkIdleTimeout);
-} // Calls the provided callback with additional resources
-
+}
 
+// Calls the provided callback with additional resources
 function processSnapshotResources({
   domSnapshot,
   resources,
   ...snapshot
 }) {
   var _resources;
+  resources = [...(((_resources = resources) === null || _resources === void 0 ? void 0 : _resources.values()) ?? [])];
 
-  resources = [...(((_resources = resources) === null || _resources === void 0 ? void 0 : _resources.values()) ?? [])]; // find or create a root resource if one does not exist
-
+  // find or create a root resource if one does not exist
   let root = resources.find(r => r.content === domSnapshot);
-
   if (!root) {
     root = createRootResource(snapshot.url, domSnapshot);
     resources.unshift(root);
-  } // inject Percy CSS
-
+  }
 
+  // inject Percy CSS
   if (snapshot.percyCSS) {
     let css = createPercyCSSResource(root.url, snapshot.percyCSS);
-    resources.push(css); // replace root contents and associated properties
+    resources.push(css);
 
+    // replace root contents and associated properties
     Object.assign(root, createRootResource(root.url, root.content.replace(/(<\/body>)(?!.*\1)/is, `<link data-percy-specific-css rel="stylesheet" href="${css.pathname}"/>` + '$&')));
-  } // include associated snapshot logs matched by meta information
-
+  }
 
+  // include associated snapshot logs matched by meta information
   resources.push(createLogResource(logger.query(log => {
     var _log$meta$snapshot;
-
     return ((_log$meta$snapshot = log.meta.snapshot) === null || _log$meta$snapshot === void 0 ? void 0 : _log$meta$snapshot.name) === snapshot.meta.snapshot.name;
   })));
-  return { ...snapshot,
+  return {
+    ...snapshot,
     resources
   };
-} // Triggers the capture of resource requests for a page by iterating over snapshot widths to resize
-// the page and calling any provided execute options.
-
+}
 
+// Triggers the capture of resource requests for a page by iterating over snapshot widths to resize
+// the page and calling any provided execute options.
 async function* captureSnapshotResources(page, snapshot, options) {
   let {
     discovery,
@@ -109,50 +107,52 @@ async function* captureSnapshotResources(page, snapshot, options) {
     captureWidths,
     deviceScaleFactor,
     mobile
-  } = options; // used to take snapshots and remove any discovered root resource
+  } = options;
 
+  // used to take snapshots and remove any discovered root resource
   let takeSnapshot = async (options, width) => {
-    if (captureWidths) options = { ...options,
+    if (captureWidths) options = {
+      ...options,
       width
     };
     let captured = await page.snapshot(options);
     captured.resources.delete(normalizeURL(captured.url));
     capture(processSnapshotResources(captured));
     return captured;
-  }; // used to resize the using capture options
-
+  };
 
+  // used to resize the using capture options
   let resizePage = width => page.resize({
     height: snapshot.minHeight,
     deviceScaleFactor,
     mobile,
     width
-  }); // navigate to the url
-
+  });
 
+  // navigate to the url
   yield resizePage(snapshot.widths[0]);
   yield page.goto(snapshot.url);
-
   if (snapshot.execute) {
     // when any execute options are provided, inject snapshot options
-
     /* istanbul ignore next: cannot detect coverage of injected code */
     yield page.eval((_, s) => window.__PERCY__.snapshot = s, snapshot);
     yield page.evaluate(snapshot.execute.afterNavigation);
-  } // iterate over additional snapshots for proper DOM capturing
-
+  }
 
+  // iterate over additional snapshots for proper DOM capturing
   for (let additionalSnapshot of [baseSnapshot, ...additionalSnapshots]) {
     let isBaseSnapshot = additionalSnapshot === baseSnapshot;
-    let snap = { ...baseSnapshot,
+    let snap = {
+      ...baseSnapshot,
       ...additionalSnapshot
     };
     let {
       widths,
       execute
     } = snap;
-    let [width] = widths; // iterate over widths to trigger reqeusts and capture other widths
+    let [width] = widths;
 
+    // iterate over widths to trigger reqeusts and capture other widths
     if (isBaseSnapshot || captureWidths) {
       for (let i = 0; i < widths.length - 1; i++) {
         if (captureWidths) yield takeSnapshot(snap, width);
@@ -162,38 +162,38 @@ async function* captureSnapshotResources(page, snapshot, options) {
         yield page.evaluate(execute === null || execute === void 0 ? void 0 : execute.afterResize);
       }
     }
-
     if (capture && !snapshot.domSnapshot) {
       // capture this snapshot and update the base snapshot after capture
       let captured = yield takeSnapshot(snap, width);
-      if (isBaseSnapshot) baseSnapshot = captured; // resize back to the initial width when capturing additional snapshot widths
+      if (isBaseSnapshot) baseSnapshot = captured;
 
+      // resize back to the initial width when capturing additional snapshot widths
       if (captureWidths && additionalSnapshots.length) {
         let l = additionalSnapshots.indexOf(additionalSnapshot) + 1;
         if (l < additionalSnapshots.length) yield resizePage(snapshot.widths[0]);
       }
     }
-  } // recursively trigger resource requests for any alternate device pixel ratio
-
+  }
 
+  // recursively trigger resource requests for any alternate device pixel ratio
   if (deviceScaleFactor !== discovery.devicePixelRatio) {
     yield waitForDiscoveryNetworkIdle(page, discovery);
     yield* captureSnapshotResources(page, snapshot, {
       deviceScaleFactor: discovery.devicePixelRatio,
       mobile: true
     });
-  } // wait for final network idle when not capturing DOM
-
+  }
 
+  // wait for final network idle when not capturing DOM
   if (capture && snapshot.domSnapshot) {
     yield waitForDiscoveryNetworkIdle(page, discovery);
     capture(processSnapshotResources(snapshot));
   }
-} // Pushes all provided snapshots to a discovery queue with the provided callback, yielding to each
+}
+
+// Pushes all provided snapshots to a discovery queue with the provided callback, yielding to each
 // one concurrently. When skipping asset discovery, the callback is called immediately for each
 // snapshot, also processing snapshot resources when not dry-running.
-
-
 export async function* discoverSnapshotResources(queue, options, callback) {
   let {
     snapshots,
@@ -202,28 +202,27 @@ export async function* discoverSnapshotResources(queue, options, callback) {
   } = options;
   yield* yieldAll(snapshots.reduce((all, snapshot) => {
     debugSnapshotOptions(snapshot);
-
     if (skipDiscovery) {
       let {
         additionalSnapshots,
         ...baseSnapshot
       } = snapshot;
       additionalSnapshots = dryRun && additionalSnapshots || [];
-
       for (let snap of [baseSnapshot, ...additionalSnapshots]) {
         callback(dryRun ? snap : processSnapshotResources(snap));
       }
     } else {
       all.push(queue.push(snapshot, callback));
     }
-
     return all;
   }, []));
-} // Used to cache resources across core instances
+}
 
-const RESOURCE_CACHE_KEY = Symbol('resource-cache'); // Creates an asset discovery queue that uses the percy browser instance to create a page for each
-// snapshot which is used to intercept and capture snapshot resource requests.
+// Used to cache resources across core instances
+const RESOURCE_CACHE_KEY = Symbol('resource-cache');
 
+// Creates an asset discovery queue that uses the percy browser instance to create a page for each
+// snapshot which is used to intercept and capture snapshot resource requests.
 export function createDiscoveryQueue(percy) {
   let {
     concurrency
@@ -232,19 +231,23 @@ export function createDiscoveryQueue(percy) {
   let cache;
   return queue.set({
     concurrency
-  }) // on start, launch the browser and run the queue
+  })
+  // on start, launch the browser and run the queue
   .handle('start', async () => {
     cache = percy[RESOURCE_CACHE_KEY] = new Map();
     await percy.browser.launch();
     queue.run();
-  }) // on end, close the browser
+  })
+  // on end, close the browser
   .handle('end', async () => {
     await percy.browser.close();
-  }) // snapshots are unique by name; when deferred also by widths
+  })
+  // snapshots are unique by name; when deferred also by widths
   .handle('find', ({
     name,
     widths
-  }, snapshot) => snapshot.name === name && (!percy.deferUploads || !widths || widths.join() === snapshot.widths.join())) // initialize the root resource for DOM snapshots
+  }, snapshot) => snapshot.name === name && (!percy.deferUploads || !widths || widths.join() === snapshot.widths.join()))
+  // initialize the root resource for DOM snapshots
   .handle('push', snapshot => {
     let {
       url,
@@ -252,13 +255,16 @@ export function createDiscoveryQueue(percy) {
     } = snapshot;
     let root = domSnapshot && createRootResource(url, domSnapshot);
     let resources = new Map(root ? [[root.url, root]] : []);
-    return { ...snapshot,
+    return {
+      ...snapshot,
       resources
     };
-  }) // discovery resources for snapshots and call the callback for each discovered snapshot
+  })
+  // discovery resources for snapshots and call the callback for each discovered snapshot
   .handle('task', async function* (snapshot, callback) {
-    percy.log.debug(`Discovering resources: ${snapshot.name}`, snapshot.meta); // create a new browser page
+    percy.log.debug(`Discovering resources: ${snapshot.name}`, snapshot.meta);
 
+    // create a new browser page
     let page = yield percy.browser.page({
       enableJavaScript: snapshot.enableJavaScript ?? !snapshot.domSnapshot,
       networkIdleTimeout: snapshot.discovery.networkIdleTimeout,
@@ -276,7 +282,6 @@ export function createDiscoveryQueue(percy) {
         saveResource: r => snapshot.resources.set(r.url, r) && cache.set(r.url, r)
       }
     });
-
     try {
       yield* captureSnapshotResources(page, snapshot, {
         captureWidths: !snapshot.domSnapshot && percy.deferUploads,

package/dist/install.js

@@ -3,27 +3,26 @@ import url from 'url';
 import path from 'path';
 import https from 'https';
 import logger from '@percy/logger';
-import { ProxyHttpsAgent } from '@percy/client/utils'; // Formats a raw byte integer as a string
+import { ProxyHttpsAgent } from '@percy/client/utils';
 
+// Formats a raw byte integer as a string
 function formatBytes(int) {
   let units = ['kB', 'MB', 'GB'];
   let base = 1024;
   let u = -1;
   if (Math.abs(int) < base) return `${int}B`;
-
   while (Math.abs(int) >= base && u++ < 2) int /= base;
-
   return `${int.toFixed(1)}${units[u]}`;
-} // Formats milleseconds as "MM:SS"
-
+}
 
+// Formats milleseconds as "MM:SS"
 function formatTime(ms) {
   let minutes = (ms / 1000 / 60).toString().split('.')[0].padStart(2, '0');
   let seconds = (ms / 1000 % 60).toFixed().padStart(2, '0');
   return `${minutes}:${seconds}`;
-} // Formats progress as ":prefix [:bar] :ratio :percent :eta"
-
+}
 
+// Formats progress as ":prefix [:bar] :ratio :percent :eta"
 function formatProgress(prefix, total, start, progress) {
   let width = 20;
   let ratio = progress === total ? 1 : Math.min(Math.max(progress / total, 0), 1);
@@ -33,9 +32,9 @@ function formatProgress(prefix, total, start, progress) {
   let elapsed = Date.now() - start;
   let eta = ratio >= 1 ? 0 : elapsed * (total / progress - 1);
   return `${prefix} [${barContent}] ` + `${formatBytes(progress)}/${formatBytes(total)} ` + `${percent}% ${formatTime(eta)}`;
-} // Returns an item from the map keyed by the current platform
-
+}
 
+// Returns an item from the map keyed by the current platform
 export function selectByPlatform(map) {
   let {
     platform,
@@ -44,9 +43,10 @@ export function selectByPlatform(map) {
   if (platform === 'win32' && arch === 'x64') platform = 'win64';
   if (platform === 'darwin' && arch === 'arm64') platform = 'darwinArm';
   return map[platform];
-} // Downloads and extracts an executable from a url into a local directory, returning the full path
-// to the extracted binary. Skips installation if the executable already exists at the binary path.
+}
 
+// Downloads and extracts an executable from a url into a local directory, returning the full path
+// to the extracted binary. Skips installation if the executable already exists at the binary path.
 export async function download({
   name,
   revision,
@@ -58,30 +58,28 @@ export async function download({
   let outdir = path.join(directory, revision);
   let archive = path.join(outdir, decodeURIComponent(url.split('/').pop()));
   let exec = path.join(outdir, executable);
-
   if (!fs.existsSync(exec)) {
     let log = logger('core:install');
     let premsg = `Downloading ${name} ${revision}`;
     log.progress(`${premsg}...`);
-
     try {
       // ensure the out directory exists
       await fs.promises.mkdir(outdir, {
         recursive: true
-      }); // download the file at the given URL
+      });
 
+      // download the file at the given URL
       await new Promise((resolve, reject) => https.get(url, {
         agent: new ProxyHttpsAgent() // allow proxied requests
-
       }, response => {
         // on failure, resume the response before rejecting
         if (response.statusCode !== 200) {
           response.resume();
           reject(new Error(`Download failed: ${response.statusCode} - ${url}`));
           return;
-        } // log progress
-
+        }
 
+        // log progress
         if (log.shouldLog('info') && logger.stdout.isTTY) {
           let total = parseInt(response.headers['content-length'], 10);
           let start, progress;
@@ -90,14 +88,16 @@ export async function download({
             progress = (progress ?? 0) + chunk.length;
             log.progress(formatProgress(premsg, total, start, progress));
           });
-        } // pipe the response directly to a file
-
+        }
 
+        // pipe the response directly to a file
         response.pipe(fs.createWriteStream(archive).on('finish', resolve).on('error', reject));
-      }).on('error', reject)); // extract the downloaded file
+      }).on('error', reject));
 
-      await extract(archive, outdir); // log success
+      // extract the downloaded file
+      await extract(archive, outdir);
 
+      // log success
       log.info(`Successfully downloaded ${name} ${revision}`);
     } finally {
       // always cleanup the archive
@@ -105,12 +105,13 @@ export async function download({
         await fs.promises.unlink(archive);
       }
     }
-  } // return the path to the executable
-
+  }
 
+  // return the path to the executable
   return exec;
-} // Installs a revision of Chromium to a local directory
+}
 
+// Installs a revision of Chromium to a local directory
 export function chromium({
   // default directory is within @percy/core package root
   directory = path.resolve(url.fileURLToPath(import.meta.url), '../../.local-chromium'),
@@ -120,7 +121,6 @@ export function chromium({
   let extract = (i, o) => import('extract-zip').then(ex => ex.default(i, {
     dir: o
   }));
-
   let url = 'https://storage.googleapis.com/chromium-browser-snapshots/' + selectByPlatform({
     linux: `Linux_x64/${revision}/chrome-linux.zip`,
     darwin: `Mac/${revision}/chrome-mac.zip`,
@@ -143,14 +143,16 @@ export function chromium({
     directory,
     executable
   });
-} // default chromium revisions corresponds to v96.0.4664.0
+}
 
+// default chromium revisions corresponds to v96.0.4664.0
 chromium.revisions = {
   linux: '929511',
   win64: '929483',
   win32: '929483',
   darwin: '929475',
   darwinArm: '929475'
-}; // export the namespace by default
+};
 
+// export the namespace by default
 export * as default from './install.js';