@percy/core 1.0.0-beta.68 → 1.0.0-beta.71

package/dist/browser.js

@@ -29,6 +29,10 @@ var _page = _interopRequireDefault(require("./page"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
@@ -61,12 +65,12 @@ class Browser extends _events.default {
 
     _defineProperty(this, "closed", false);
 
-    _callbacks.set(this, {
+    _classPrivateFieldInitSpec(this, _callbacks, {
       writable: true,
       value: new Map()
     });
 
-    _lastid.set(this, {
+    _classPrivateFieldInitSpec(this, _lastid, {
       writable: true,
       value: 0
     });
@@ -124,7 +128,8 @@ class Browser extends _events.default {
 
     this.profile = await _fs.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), 'percy-browser-')); // collect args to pass to the browser process
 
-    let args = [...this.args, `--user-data-dir=${this.profile}`]; // spawn the browser process detached in its own group and session
+    let args = [...this.args, `--user-data-dir=${this.profile}`];
+    this.log.debug('Launching browser'); // spawn the browser process detached in its own group and session
 
     this.process = (0, _crossSpawn.default)(this.executable, args, {
       detached: process.platform !== 'win32'
@@ -139,6 +144,7 @@ class Browser extends _events.default {
     this.ws.on('message', data => this._handleMessage(data)); // get version information
 
     this.version = await this.send('Browser.getVersion');
+    this.log.debug(`Browser connected: ${this.version.product}`);
   }
 
   isConnected() {
@@ -150,7 +156,8 @@ class Browser extends _events.default {
   async close() {
     var _this$process4, _this$ws2;
 
-    if (this._closed) return this._closed; // resolves when the browser has closed
+    if (this._closed) return this._closed;
+    this.log.debug('Closing browser'); // resolves when the browser has closed
 
     this._closed = Promise.all([new Promise(resolve => {
       /* istanbul ignore next: race condition paranoia */
@@ -177,6 +184,8 @@ class Browser extends _events.default {
           this.log.debug(error);
         });
       }
+
+      this.log.debug('Browser closed');
     }); // reject any pending callbacks
 
     for (let callback of _classPrivateFieldGet(this, _callbacks).values()) {
@@ -316,7 +325,7 @@ class Browser extends _events.default {
     } else if (data.method === 'Target.detachedFromTarget') {
       // remove the old session reference when detached from a target
       let session = this.sessions.get(data.params.sessionId);
-      this.sessions.delete(session.sessionId);
+      this.sessions.delete(data.params.sessionId);
       session === null || session === void 0 ? void 0 : session._handleClose();
     }
 

package/dist/config.js

@@ -4,18 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.configMigration = configMigration;
+exports.snapshotDOMSchema = exports.schemas = exports.migrations = exports.configSchema = void 0;
 exports.snapshotMigration = snapshotMigration;
-exports.getSnapshotConfig = getSnapshotConfig;
-exports.migrations = exports.schemas = exports.snapshotDOMSchema = exports.snapshotSchema = exports.configSchema = void 0;
-
-var _assert = require("assert");
-
-var _config = _interopRequireDefault(require("@percy/config"));
-
-var _utils = require("@percy/config/dist/utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+exports.snapshotSchema = void 0;
 // Common config options used in Percy commands
 const configSchema = {
   snapshot: {
@@ -362,65 +353,5 @@ function snapshotMigration(config, util) {
 
 const schemas = [configSchema, snapshotSchema, snapshotDOMSchema];
 exports.schemas = schemas;
-const migrations = [['/config', configMigration], ['/snapshot', snapshotMigration]]; // Validate and merge per-snapshot configuration options with global configuration options.
-
-exports.migrations = migrations;
-
-function getSnapshotConfig(options, {
-  snapshot,
-  discovery
-}, log) {
-  var _ref, _config$widths;
-
-  // prune client and env info from being validated
-  let {
-    clientInfo,
-    environmentInfo,
-    ...config
-  } = _config.default.migrate(options, '/snapshot'); // throw an error when missing required options
-
-
-  (0, _assert.strict)(config.url, 'Missing required URL for snapshot');
-  (0, _assert.strict)((_ref = (_config$widths = config.widths) !== null && _config$widths !== void 0 ? _config$widths : snapshot.widths) === null || _ref === void 0 ? void 0 : _ref.length, 'Missing required widths for snapshot'); // validate and scrub according to dom snaphot presence
-
-  let errors = _config.default.validate(config, config.domSnapshot ? '/snapshot/dom' : '/snapshot');
-
-  if (errors) {
-    log.warn('Invalid snapshot options:');
-
-    for (let e of errors) log.warn(`- ${e.path}: ${e.message}`);
-  } // parse the URL to construct defaults
-
-
-  let url = new URL(options.url); // inherit options from the config
-
-  return (0, _utils.merge)([snapshot, {
-    // default to the URL /pathname?search#hash
-    name: `${url.pathname}${url.search}${url.hash}`,
-    // add back client and environment information
-    clientInfo,
-    environmentInfo,
-    // only specific discovery options are used per-snapshot
-    discovery: {
-      allowedHostnames: [url.hostname, ...discovery.allowedHostnames],
-      requestHeaders: discovery.requestHeaders,
-      authorization: discovery.authorization,
-      disableCache: discovery.disableCache,
-      userAgent: discovery.userAgent
-    }
-  }, config], (path, prev, next) => {
-    switch (path.join('.')) {
-      case 'widths':
-        // override and sort widths
-        return [path, next.sort((a, b) => a - b)];
-
-      case 'percyCSS':
-        // concatenate percy css
-        return [path, [prev, next].filter(Boolean).join('\n')];
-
-      case 'execute':
-        // shorthand for execute.beforeSnapshot
-        return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
-    }
-  });
-}
+const migrations = [['/config', configMigration], ['/snapshot', snapshotMigration]];
+exports.migrations = migrations;

package/dist/discovery.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createRequestHandler = createRequestHandler;
-exports.createRequestFinishedHandler = createRequestFinishedHandler;
 exports.createRequestFailedHandler = createRequestFailedHandler;
+exports.createRequestFinishedHandler = createRequestFinishedHandler;
+exports.createRequestHandler = createRequestHandler;
 
 var _logger = _interopRequireDefault(require("@percy/logger"));
 
@@ -34,10 +34,10 @@ function createRequestHandler(network, {
       let resource = getResource(url);
 
       if (resource !== null && resource !== void 0 && resource.root) {
-        log.debug('-> Serving root resource', meta);
+        log.debug('- Serving root resource', meta);
         await request.respond(resource);
       } else if (resource && !disableCache) {
-        log.debug('-> Resource cache hit', meta);
+        log.debug('- Resource cache hit', meta);
         await request.respond(resource);
       } else {
         await request.continue();
@@ -57,7 +57,7 @@ function createRequestFinishedHandler(network, {
   allowedHostnames,
   disableCache,
   getResource,
-  addResource
+  saveResource
 }) {
   let log = (0, _logger.default)('core:discovery');
   return async request => {
@@ -80,17 +80,17 @@ function createRequestFinishedHandler(network, {
         /* istanbul ignore next: sanity check */
 
         if (!response) {
-          return log.debug('-> Skipping no response', meta);
+          return log.debug('- Skipping no response', meta);
         } else if (!capture) {
-          return log.debug('-> Skipping remote resource', meta);
+          return log.debug('- Skipping remote resource', meta);
         } else if (!body.length) {
-          return log.debug('-> Skipping empty response', meta);
+          return log.debug('- Skipping empty response', meta);
         } else if (body.length > MAX_RESOURCE_SIZE) {
-          return log.debug('-> Skipping resource larger than 15MB', meta);
+          return log.debug('- Skipping resource larger than 15MB', meta);
         } else if (!ALLOWED_STATUSES.includes(response.status)) {
-          return log.debug(`-> Skipping disallowed status [${response.status}]`, meta);
+          return log.debug(`- Skipping disallowed status [${response.status}]`, meta);
         } else if (!enableJavaScript && !ALLOWED_RESOURCES.includes(request.type)) {
-          return log.debug(`-> Skipping disallowed resource type [${request.type}]`, meta);
+          return log.debug(`- Skipping disallowed resource type [${request.type}]`, meta);
         }
 
         resource = (0, _utils.createResource)(url, body, response.mimeType, {
@@ -101,11 +101,11 @@ function createRequestFinishedHandler(network, {
             [key]: value.split('\n')
           }), {})
         });
-        log.debug(`-> sha: ${resource.sha}`, meta);
-        log.debug(`-> mimetype: ${resource.mimetype}`, meta);
+        log.debug(`- sha: ${resource.sha}`, meta);
+        log.debug(`- mimetype: ${resource.mimetype}`, meta);
       }
 
-      addResource(resource);
+      saveResource(resource);
     } catch (error) {
       log.debug(`Encountered an error processing resource: ${url}`, meta);
       log.debug(error);

package/dist/install.js

@@ -26,8 +26,8 @@ function formatBytes(int) {
 
 
 function formatTime(ms) {
-  let minutes = (ms / 1000 / 60).toFixed().padStart(2, '0');
-  let seconds = (ms / 1000).toFixed().padStart(2, '0');
+  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"
 
@@ -38,9 +38,7 @@ function formatProgress(prefix, total, start, progress) {
   let percent = Math.floor(ratio * 100).toFixed(0);
   let barLen = Math.round(width * ratio);
   let barContent = Array(Math.max(0, barLen + 1)).join('=') + Array(Math.max(0, width - barLen + 1)).join(' ');
-  let elapsed = new Date() - start;
-  /* istanbul ignore next: eta in testing is always 0 */
-
+  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
@@ -144,7 +142,7 @@ async function install({
           response.on('data', chunk => {
             var _start, _progress;
 
-            (_start = start) !== null && _start !== void 0 ? _start : start = new Date();
+            (_start = start) !== null && _start !== void 0 ? _start : start = Date.now();
             progress = ((_progress = progress) !== null && _progress !== void 0 ? _progress : 0) + chunk.length;
             log.progress(formatProgress(premsg, total, start, progress));
           });

package/dist/network.js

@@ -13,6 +13,10 @@ var _discovery = require("./discovery");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
@@ -37,22 +41,22 @@ class Network {
 
     _defineProperty(this, "log", (0, _logger.default)('core:network'));
 
-    _pending.set(this, {
+    _classPrivateFieldInitSpec(this, _pending, {
       writable: true,
       value: new Map()
     });
 
-    _requests.set(this, {
+    _classPrivateFieldInitSpec(this, _requests, {
       writable: true,
       value: new Map()
     });
 
-    _intercepts.set(this, {
+    _classPrivateFieldInitSpec(this, _intercepts, {
       writable: true,
       value: new Map()
     });
 
-    _authentications.set(this, {
+    _classPrivateFieldInitSpec(this, _authentications, {
       writable: true,
       value: new Set()
     });
@@ -323,7 +327,7 @@ class Network {
         let msg = 'Timed out waiting for network requests to idle.';
 
         if (this.log.shouldLog('debug')) {
-          msg += `\n\n  ${['Active requests:', ...requests.map(r => r.url)].join('\n  -> ')}\n`;
+          msg += `\n\n  ${['Active requests:', ...requests.map(r => r.url)].join('\n  - ')}\n`;
         }
 
         throw new Error(msg);

package/dist/page.js

@@ -230,7 +230,8 @@ class Page {
     execute,
     ...options
   }) {
-    // wait for any specified timeout
+    this.log.debug(`Taking snapshot: ${name}`, this.meta); // wait for any specified timeout
+
     if (waitForTimeout) {
       this.log.debug(`Wait for ${waitForTimeout}ms timeout`, this.meta);
       await new Promise(resolve => setTimeout(resolve, waitForTimeout));

package/dist/percy.js

@@ -9,6 +9,8 @@ var _client = _interopRequireDefault(require("@percy/client"));
 
 var _config = _interopRequireDefault(require("@percy/config"));
 
+var _utils = require("@percy/config/dist/utils");
+
 var _logger = _interopRequireDefault(require("@percy/logger"));
 
 var _queue = _interopRequireDefault(require("./queue"));
@@ -17,12 +19,14 @@ var _browser = _interopRequireDefault(require("./browser"));
 
 var _server = _interopRequireDefault(require("./server"));
 
-var _config2 = require("./config");
-
-var _utils = require("./utils");
+var _snapshot = require("./snapshot");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
@@ -31,8 +35,6 @@ function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!priva
 
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 
-var _cache = /*#__PURE__*/new WeakMap();
-
 var _uploads = /*#__PURE__*/new WeakMap();
 
 var _snapshots = /*#__PURE__*/new WeakMap();
@@ -56,6 +58,8 @@ class Percy {
     deferUploads,
     // run without uploading anything
     skipUploads,
+    // implies `skipUploads` and also skips asset discovery
+    dryRun,
     // configuration filepath
     config,
     // provided to @percy/client
@@ -73,24 +77,20 @@ class Percy {
 
     _defineProperty(this, "readyState", null);
 
-    _cache.set(this, {
-      writable: true,
-      value: new Map()
-    });
-
-    _uploads.set(this, {
+    _classPrivateFieldInitSpec(this, _uploads, {
       writable: true,
       value: new _queue.default()
     });
 
-    _snapshots.set(this, {
+    _classPrivateFieldInitSpec(this, _snapshots, {
       writable: true,
       value: new _queue.default()
     });
 
     if (loglevel) this.loglevel(loglevel);
-    this.deferUploads = skipUploads || deferUploads;
-    this.skipUploads = skipUploads;
+    this.dryRun = !!dryRun;
+    this.skipUploads = this.dryRun || !!skipUploads;
+    this.deferUploads = this.skipUploads || !!deferUploads;
     this.config = _config.default.load({
       overrides: options,
       path: config
@@ -123,6 +123,36 @@ class Percy {
 
   address() {
     return `http://localhost:${this.port}`;
+  } // Set client & environment info, and override loaded config options
+
+
+  setConfig({
+    clientInfo,
+    environmentInfo,
+    ...config
+  }) {
+    this.client.addClientInfo(clientInfo);
+    this.client.addEnvironmentInfo(environmentInfo); // normalize config and do nothing if empty
+
+    config = _config.default.normalize(config, {
+      schema: '/config'
+    });
+    if (!config) return this.config; // validate provided config options
+
+    let errors = _config.default.validate(config);
+
+    if (errors) {
+      this.log.warn('Invalid config:');
+
+      for (let e of errors) this.log.warn(`- ${e.path}: ${e.message}`);
+    } // merge and override existing config options
+
+
+    this.config = (0, _utils.merge)([this.config, config], (path, prev, next) => {
+      // replace arrays instead of merging
+      return Array.isArray(next) && [path, next];
+    });
+    return this.config;
   } // Resolves once snapshot and upload queues are idle
 
 
@@ -186,7 +216,7 @@ class Percy {
       // when not deferred, wait until the build is created first
       if (!this.deferUploads) await buildTask; // launch the discovery browser
 
-      await this.browser.launch(this.config.discovery.launchOptions); // if there is a server, start listening
+      if (!this.dryRun) await this.browser.launch(); // if there is a server, start listening
 
       await ((_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.listen(this.port)); // mark this process as running
 
@@ -226,17 +256,22 @@ class Percy {
     };
     if (force) this.log.info('Stopping percy...', meta); // close the snapshot queue and wait for it to empty
 
-    if (_classPrivateFieldGet(this, _snapshots).close().length) {
-      await _classPrivateFieldGet(this, _snapshots).empty(len => {
-        this.log.progress(`Processing ${len}` + ` snapshot${len !== 1 ? 's' : ''}...`, !!len);
-      });
+    if (_classPrivateFieldGet(this, _snapshots).close().size) {
+      await _classPrivateFieldGet(this, _snapshots).empty(s => !this.dryRun && this.log.progress(`Processing ${s} snapshot${s !== 1 ? 's' : ''}...`, !!s));
     } // run, close, and wait for the upload queue to empty
 
 
-    if (!this.skipUploads && _classPrivateFieldGet(this, _uploads).run().close().length) {
-      await _classPrivateFieldGet(this, _uploads).empty(len => {
-        this.log.progress(`Uploading ${len}` + ` snapshot${len !== 1 ? 's' : ''}...`, !!len);
+    if (!this.skipUploads && _classPrivateFieldGet(this, _uploads).run().close().size) {
+      await _classPrivateFieldGet(this, _uploads).empty(s => {
+        this.log.progress(`Uploading ${s} snapshot${s !== 1 ? 's' : ''}...`, !!s);
       });
+    } // if dry-running, print the total number of snapshots that would be uploaded
+
+
+    if (this.dryRun && _classPrivateFieldGet(this, _uploads).size) {
+      let total = _classPrivateFieldGet(this, _uploads).size - 1; // subtract the build task
+
+      this.log.info(`Found ${total} snapshot${total !== 1 ? 's' : ''}`);
     } // close the any running server and browser
 
 
@@ -271,202 +306,62 @@ class Percy {
   snapshot(options) {
     if (this.readyState !== 1) {
       throw new Error('Not running');
-    }
+    } // handle multiple snapshots
 
-    let {
-      url,
-      name,
-      discovery,
-      domSnapshot,
-      execute,
-      waitForTimeout,
-      waitForSelector,
-      additionalSnapshots,
-      ...conf
-    } = (0, _config2.getSnapshotConfig)(options, this.config, this.log);
-    let meta = {
-      snapshot: {
-        name
-      },
-      build: this.build
-    };
 
-    let maybeDebug = (val, msg) => {
-      if (val != null) this.log.debug(msg(val), meta);
-    }; // clear any existing pending upload for the same snapshot (for retries)
+    if (Array.isArray(options)) {
+      return Promise.all(options.map(o => this.snapshot(o)));
+    } // get derived snapshot config options
 
 
-    _classPrivateFieldGet(this, _uploads).clear(`upload/${name}`); // resolves after asset discovery has finished and the upload has been queued
+    let snapshot = (0, _snapshot.getSnapshotConfig)(this, options); // clear any existing snapshot uploads of the same name (for retries)
 
+    for (let {
+      name
+    } of [snapshot, ...(snapshot.additionalSnapshots || [])]) {
+      _classPrivateFieldGet(this, _uploads).cancel(`upload/${name}`);
+    } // resolves after asset discovery has finished and uploads have been queued
 
-    return _classPrivateFieldGet(this, _snapshots).push(`snapshot/${name}`, async () => {
-      let resources = new Map();
-      let root, page;
 
+    return _classPrivateFieldGet(this, _snapshots).push(`snapshot/${snapshot.name}`, async function* () {
       try {
-        var _options$discovery, _options$discovery2, _options$discovery3, _options$discovery4, _options$discovery5, _conf$enableJavaScrip;
-
-        this.log.debug('---------');
-        this.log.debug('Handling snapshot:', meta);
-        this.log.debug(`-> name: ${name}`, meta);
-        this.log.debug(`-> url: ${url}`, meta);
-        maybeDebug(conf.widths, v => `-> widths: ${v.join('px, ')}px`);
-        maybeDebug(conf.minHeight, v => `-> minHeight: ${v}px`);
-        maybeDebug(conf.enableJavaScript, v => `-> enableJavaScript: ${v}`);
-        maybeDebug((_options$discovery = options.discovery) === null || _options$discovery === void 0 ? void 0 : _options$discovery.allowedHostnames, v => `-> discovery.allowedHostnames: ${v}`);
-        maybeDebug((_options$discovery2 = options.discovery) === null || _options$discovery2 === void 0 ? void 0 : _options$discovery2.requestHeaders, v => `-> discovery.requestHeaders: ${JSON.stringify(v)}`);
-        maybeDebug((_options$discovery3 = options.discovery) === null || _options$discovery3 === void 0 ? void 0 : _options$discovery3.authorization, v => `-> discovery.authorization: ${JSON.stringify(v)}`);
-        maybeDebug((_options$discovery4 = options.discovery) === null || _options$discovery4 === void 0 ? void 0 : _options$discovery4.disableCache, v => `-> discovery.disableCache: ${v}`);
-        maybeDebug((_options$discovery5 = options.discovery) === null || _options$discovery5 === void 0 ? void 0 : _options$discovery5.userAgent, v => `-> discovery.userAgent: ${v}`);
-        maybeDebug(options.waitForTimeout, v => `-> waitForTimeout: ${v}`);
-        maybeDebug(options.waitForSelector, v => `-> waitForSelector: ${v}`);
-        maybeDebug(options.execute, v => `-> execute: ${v}`);
-        maybeDebug(conf.clientInfo, v => `-> clientInfo: ${v}`);
-        maybeDebug(conf.environmentInfo, v => `-> environmentInfo: ${v}`); // create the root resource if a dom snapshot was provided
-
-        if (domSnapshot) {
-          root = (0, _utils.createRootResource)(url, domSnapshot);
-        } // open a new browser page
-
-
-        page = await this.browser.page({
-          networkIdleTimeout: this.config.discovery.networkIdleTimeout,
-          enableJavaScript: (_conf$enableJavaScrip = conf.enableJavaScript) !== null && _conf$enableJavaScrip !== void 0 ? _conf$enableJavaScrip : !domSnapshot,
-          requestHeaders: discovery.requestHeaders,
-          authorization: discovery.authorization,
-          userAgent: discovery.userAgent,
-          meta,
-          // enable network inteception
-          intercept: {
-            disableCache: discovery.disableCache,
-            enableJavaScript: conf.enableJavaScript,
-            allowedHostnames: discovery.allowedHostnames,
-            getResource: url => {
-              var _root;
-
-              return url === ((_root = root) === null || _root === void 0 ? void 0 : _root.url) ? root : resources.get(url) || _classPrivateFieldGet(this, _cache).get(url);
-            },
-            addResource: resource => {
-              if (resource.root) return;
-              resources.set(resource.url, resource);
-
-              _classPrivateFieldGet(this, _cache).set(resource.url, resource);
-            }
-          }
-        }); // copy widths to prevent mutation
-
-        let widths = conf.widths.slice(); // resolves when the network is idle for discoverable assets
-
-        let discoveryIdle = () => page.network.idle(({
-          url
-        }) => (0, _utils.hostnameMatches)(discovery.allowedHostnames, url)); // set the initial page size
-
-
-        await page.resize({
-          width: widths.shift(),
-          height: conf.minHeight
-        }); // navigate to the url
-
-        await page.goto(url); // evaluate any necessary javascript
-
-        await page.evaluate(execute === null || execute === void 0 ? void 0 : execute.afterNavigation); // trigger resize events for other widths
-
-        for (let width of widths) {
-          await page.evaluate(execute === null || execute === void 0 ? void 0 : execute.beforeResize);
-          await discoveryIdle(); // ensure discovery idles before resizing
-
-          await page.resize({
-            width,
-            height: conf.minHeight
-          });
-          await page.evaluate(execute === null || execute === void 0 ? void 0 : execute.afterResize);
-        } // create and add a percy-css resource
-
-
-        let percyCSS = (0, _utils.createPercyCSSResource)(url, conf.percyCSS);
-        if (percyCSS) resources.set(percyCSS.url, percyCSS);
-
-        if (root) {
-          // ensure discovery finishes before uploading
-          await discoveryIdle();
-          root = (0, _utils.injectPercyCSS)(root, percyCSS);
-          this.log.info(`Snapshot taken: ${name}`, meta);
-
-          this._scheduleUpload(name, conf, [root, ...resources.values()]);
+        yield* (0, _snapshot.discoverSnapshotResources)(this, snapshot, (snap, resources) => {
+          if (!this.dryRun) this.log.info(`Snapshot taken: ${snap.name}`, snap.meta);
+
+          this._scheduleUpload(snap, resources);
+        });
+      } catch (error) {
+        if (error.message === 'Canceled') {
+          this.log.error('Received a duplicate snapshot name, ' + `the previous snapshot was canceled: ${snapshot.name}`);
         } else {
-          // capture additional snapshots sequentially
-          let rootSnapshot = {
-            name,
-            waitForTimeout,
-            waitForSelector,
-            execute
-          };
-          let allSnapshots = [rootSnapshot, ...(additionalSnapshots || [])];
-
-          for (let {
-            name,
-            prefix = '',
-            suffix = '',
-            ...opts
-          } of allSnapshots) {
-            name || (name = `${prefix}${rootSnapshot.name}${suffix}`);
-            this.log.debug(`Taking snapshot: ${name}`, meta); // will wait for timeouts, selectors, and additional network activity
-
-            let {
-              url,
-              dom
-            } = await page.snapshot({ ...conf,
-              ...opts
-            });
-            let root = (0, _utils.injectPercyCSS)((0, _utils.createRootResource)(url, dom), percyCSS);
-            resources.delete(root.url); // remove any discovered root resource
-
-            this.log.info(`Snapshot taken: ${name}`, meta);
-
-            this._scheduleUpload(name, conf, [root, ...resources.values()]);
-          }
+          this.log.error(`Encountered an error taking snapshot: ${snapshot.name}`, snapshot.meta);
+          this.log.error(error, snapshot.meta);
         }
-      } catch (error) {
-        this.log.error(`Encountered an error taking snapshot: ${name}`, meta);
-        this.log.error(error, meta);
-      } finally {
-        var _page;
+      } // fixes an issue in Node 12 where implicit returns do not correctly resolve the async
+      // generator objects — https://crbug.com/v8/10238
 
-        await ((_page = page) === null || _page === void 0 ? void 0 : _page.close());
-      }
-    });
+
+      return; // eslint-disable-line no-useless-return
+    }.bind(this));
   } // Queues a snapshot upload with the provided configuration options and resources
 
 
-  _scheduleUpload(name, conf, resources) {
-    _classPrivateFieldGet(this, _uploads).push(`upload/${name}`, async () => {
+  _scheduleUpload(snapshot, resources) {
+    _classPrivateFieldGet(this, _uploads).push(`upload/${snapshot.name}`, async () => {
       try {
-        // attach a log resource for debugging
-        resources = resources.concat((0, _utils.createLogResource)(_logger.default.query(l => {
-          var _l$meta$snapshot;
-
-          return ((_l$meta$snapshot = l.meta.snapshot) === null || _l$meta$snapshot === void 0 ? void 0 : _l$meta$snapshot.name) === name;
-        })));
-        await this.client.sendSnapshot(this.build.id, { ...conf,
-          name,
+        await this.client.sendSnapshot(this.build.id, { ...snapshot,
           resources
         });
       } catch (error) {
         var _error$response, _failed$detail;
 
-        let meta = {
-          snapshot: {
-            name
-          },
-          build: this.build
-        };
         let failed = ((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 422 && error.response.body.errors.find(e => {
           var _e$source;
 
           return ((_e$source = e.source) === null || _e$source === void 0 ? void 0 : _e$source.pointer) === '/data/attributes/build';
         });
-        this.log.error(`Encountered an error uploading snapshot: ${name}`, meta);
-        this.log.error((_failed$detail = failed === null || failed === void 0 ? void 0 : failed.detail) !== null && _failed$detail !== void 0 ? _failed$detail : error, meta); // build failed at some point, stop accepting snapshots
+        this.log.error(`Encountered an error uploading snapshot: ${snapshot.name}`, snapshot.meta);
+        this.log.error((_failed$detail = failed === null || failed === void 0 ? void 0 : failed.detail) !== null && _failed$detail !== void 0 ? _failed$detail : error, snapshot.meta); // build failed at some point, stop accepting snapshots
 
         if (failed) {
           this.build.failed = true;

package/dist/queue.js

@@ -7,6 +7,10 @@ exports.default = void 0;
 
 var _utils = require("./utils");
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
@@ -15,6 +19,19 @@ function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!priva
 
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 
+function isGenerator(obj) {
+  return typeof obj.next === 'function' && (typeof obj[Symbol.iterator] === 'function' || typeof obj[Symbol.asyncIterator] === 'function');
+}
+
+async function runGeneratorTask(task, arg) {
+  if (task.canceled) await task.generator.throw(new Error('Canceled'));
+  let {
+    done,
+    value
+  } = await task.generator.next(arg);
+  return done ? value : runGeneratorTask(task, value);
+}
+
 var _queued = /*#__PURE__*/new WeakMap();
 
 var _pending = /*#__PURE__*/new WeakMap();
@@ -25,12 +42,12 @@ class Queue {
 
     _defineProperty(this, "closed", false);
 
-    _queued.set(this, {
+    _classPrivateFieldInitSpec(this, _queued, {
       writable: true,
       value: new Map()
     });
 
-    _pending.set(this, {
+    _classPrivateFieldInitSpec(this, _pending, {
       writable: true,
       value: new Map()
     });
@@ -40,6 +57,7 @@ class Queue {
 
   push(id, callback, priority) {
     if (this.closed) throw new Error('Closed');
+    this.cancel(id);
     let task = {
       id,
       callback,
@@ -51,8 +69,6 @@ class Queue {
         reject
       });
 
-      _classPrivateFieldGet(this, _queued).delete(id);
-
       _classPrivateFieldGet(this, _queued).set(id, task);
 
       this._dequeue();
@@ -60,17 +76,23 @@ class Queue {
     return task.promise;
   }
 
-  clear(id) {
-    if (id != null) {
-      _classPrivateFieldGet(this, _queued).delete(id);
-    } else {
-      _classPrivateFieldGet(this, _queued).clear();
-    }
+  cancel(id) {
+    let pending = _classPrivateFieldGet(this, _pending).get(id);
+
+    if (pending) pending.canceled = true;
 
-    return this.length;
+    _classPrivateFieldGet(this, _pending).delete(id);
+
+    _classPrivateFieldGet(this, _queued).delete(id);
   }
 
-  get length() {
+  clear() {
+    _classPrivateFieldGet(this, _queued).clear();
+
+    return this.size;
+  }
+
+  get size() {
     return _classPrivateFieldGet(this, _queued).size + _classPrivateFieldGet(this, _pending).size;
   }
 
@@ -94,15 +116,17 @@ class Queue {
   }
 
   async idle() {
-    await (0, _utils.waitFor)(() => !_classPrivateFieldGet(this, _pending).size, {
+    await (0, _utils.waitFor)(() => {
+      return !_classPrivateFieldGet(this, _pending).size;
+    }, {
       idle: 10
     });
   }
 
   async empty(onCheck) {
     await (0, _utils.waitFor)(() => {
-      onCheck === null || onCheck === void 0 ? void 0 : onCheck(this.length);
-      return !this.length;
+      onCheck === null || onCheck === void 0 ? void 0 : onCheck(this.size);
+      return !this.size;
     }, {
       idle: 10
     });
@@ -135,15 +159,21 @@ class Queue {
     _classPrivateFieldGet(this, _pending).set(task.id, task);
 
     let done = (callback, arg) => {
-      _classPrivateFieldGet(this, _pending).delete(task.id);
-
+      if (!task.canceled) _classPrivateFieldGet(this, _pending).delete(task.id);
       callback(arg);
 
       this._dequeue();
     };
 
     try {
-      return Promise.resolve(task.callback()).then(done.bind(null, task.resolve)).catch(done.bind(null, task.reject));
+      let result = task.callback();
+
+      if (isGenerator(result)) {
+        task.generator = result;
+        result = runGeneratorTask(task);
+      }
+
+      return Promise.resolve(result).then(done.bind(null, task.resolve)).catch(done.bind(null, task.reject));
     } catch (err) {
       done(task.reject, err);
     }

package/dist/server.js

@@ -74,6 +74,7 @@ function createServer(routes) {
 
   context.routes = routes;
   context.server = _http.default.createServer((request, response) => {
+    request.params = new URLSearchParams(request.url.split('?')[1]);
     request.on('data', chunk => {
       request.body = (request.body || '') + chunk;
     });
@@ -123,6 +124,13 @@ function createPercyServer(percy) {
       loglevel: percy.loglevel(),
       build: percy.build
     }],
+    // remotely get and set percy config options
+    '/percy/config': ({
+      body
+    }) => [200, 'application/json', {
+      config: body ? percy.setConfig(body) : percy.config,
+      success: true
+    }],
     // responds when idle
     '/percy/idle': () => percy.idle().then(() => [200, 'application/json', {
       success: true
@@ -136,11 +144,16 @@ function createPercyServer(percy) {
       return [200, 'applicaton/javascript', content.concat(wrapper)];
     }),
     // forward snapshot requests
-    '/percy/snapshot': ({
-      body
-    }) => percy.snapshot(body).then(() => [200, 'application/json', {
-      success: true
-    }]),
+    '/percy/snapshot': async ({
+      body,
+      params
+    }) => {
+      let snapshot = percy.snapshot(body);
+      if (!params.has('async')) await snapshot;
+      return [200, 'application/json', {
+        success: true
+      }];
+    },
     // stops the instance async at the end of the event loop
     '/percy/stop': () => setImmediate(() => percy.stop()) && [200, 'application/json', {
       success: true

package/dist/session.js

@@ -13,6 +13,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
@@ -30,7 +34,7 @@ class Session extends _events.default {
 
     super();
 
-    _callbacks.set(this, {
+    _classPrivateFieldInitSpec(this, _callbacks, {
       writable: true,
       value: new Map()
     });

package/dist/snapshot.js

@@ -0,0 +1,274 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.discoverSnapshotResources = discoverSnapshotResources;
+exports.getSnapshotConfig = getSnapshotConfig;
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
+
+var _config = _interopRequireDefault(require("@percy/config"));
+
+var _utils = require("@percy/config/dist/utils");
+
+var _utils2 = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Validates and returns snapshot options merged with percy config options.
+function getSnapshotConfig(percy, options) {
+  var _ref, _snapshot$widths;
+
+  if (!options.url) throw new Error('Missing required URL for snapshot');
+  let {
+    config
+  } = percy;
+  let uri = new URL(options.url);
+  let name = options.name || `${uri.pathname}${uri.search}${uri.hash}`;
+  let meta = {
+    snapshot: {
+      name
+    },
+    build: percy.build
+  };
+  let log = (0, _logger.default)('core:snapshot'); // migrate deprecated snapshot config options
+
+  let {
+    clientInfo,
+    environmentInfo,
+    ...snapshot
+  } = _config.default.migrate(options, '/snapshot'); // throw an error when missing required widths
+
+
+  if (!((_ref = (_snapshot$widths = snapshot.widths) !== null && _snapshot$widths !== void 0 ? _snapshot$widths : percy.config.snapshot.widths) !== null && _ref !== void 0 && _ref.length)) {
+    throw new Error('Missing required widths for snapshot');
+  } // validate and scrub according to dom snaphot presence
+
+
+  let errors = _config.default.validate(snapshot, snapshot.domSnapshot ? '/snapshot/dom' : '/snapshot');
+
+  if (errors) {
+    log.warn('Invalid snapshot options:', meta);
+
+    for (let e of errors) log.warn(`- ${e.path}: ${e.message}`, meta);
+  } // inherit options from the percy config
+
+
+  return (0, _utils.merge)([config.snapshot, {
+    name,
+    meta,
+    clientInfo,
+    environmentInfo,
+    // only specific discovery options are used per-snapshot
+    discovery: {
+      allowedHostnames: [uri.hostname, ...config.discovery.allowedHostnames],
+      networkIdleTimeout: config.discovery.networkIdleTimeout,
+      requestHeaders: config.discovery.requestHeaders,
+      authorization: config.discovery.authorization,
+      disableCache: config.discovery.disableCache,
+      userAgent: config.discovery.userAgent
+    }
+  }, snapshot], (path, prev, next) => {
+    switch (path.map(k => k.toString()).join('.')) {
+      case 'widths':
+        // override and sort widths
+        return [path, next.sort((a, b) => a - b)];
+
+      case 'percyCSS':
+        // concatenate percy css
+        return [path, [prev, next].filter(Boolean).join('\n')];
+
+      case 'execute':
+        // shorthand for execute.beforeSnapshot
+        return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
+    } // ensure additional snapshots have complete names
+
+
+    if (path[0] === 'additionalSnapshots' && path.length === 2) {
+      let {
+        prefix = '',
+        suffix = '',
+        ...n
+      } = next;
+      next = {
+        name: `${prefix}${name}${suffix}`,
+        ...n
+      };
+      return [path, next];
+    }
+  });
+} // Returns a complete and valid snapshot config object and logs verbose debug logs detailing various
+// snapshot options. When `showInfo` is true, specific messages will be logged as info logs rather
+// than debug logs.
+
+
+function debugSnapshotConfig(snapshot, showInfo) {
+  let log = (0, _logger.default)('core:snapshot'); // log snapshot info
+
+  log.debug('---------', snapshot.meta);
+  if (showInfo) log.info(`Snapshot found: ${snapshot.name}`, snapshot.meta);else log.debug(`Handling 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, 'widths', v => `${v}px`);
+  debugProp(snapshot, 'minHeight', v => `${v}px`);
+  debugProp(snapshot, 'enableJavaScript');
+  debugProp(snapshot, 'waitForTimeout');
+  debugProp(snapshot, 'waitForSelector');
+  debugProp(snapshot, 'execute.afterNavigation');
+  debugProp(snapshot, 'execute.beforeResize');
+  debugProp(snapshot, 'execute.afterResize');
+  debugProp(snapshot, 'execute.beforeSnapshot');
+  debugProp(snapshot, 'discovery.allowedHostnames');
+  debugProp(snapshot, 'discovery.requestHeaders', JSON.stringify);
+  debugProp(snapshot, 'discovery.authorization', JSON.stringify);
+  debugProp(snapshot, 'discovery.disableCache');
+  debugProp(snapshot, 'discovery.userAgent');
+  debugProp(snapshot, 'clientInfo');
+  debugProp(snapshot, 'environmentInfo');
+  debugProp(snapshot, 'domSnapshot', Boolean);
+
+  for (let added of snapshot.additionalSnapshots || []) {
+    if (showInfo) log.info(`Snapshot found: ${added.name}`, snapshot.meta);else log.debug(`Additional snapshot: ${added.name}`, snapshot.meta);
+    debugProp(added, 'waitForTimeout');
+    debugProp(added, 'waitForSelector');
+    debugProp(added, 'execute');
+  }
+} // Calls the provided callback with additional resources
+
+
+function handleSnapshotResources(snapshot, map, callback) {
+  let resources = [...map.values()]; // sort the root resource first
+
+  let [root] = resources.splice(resources.findIndex(r => r.root), 1);
+  resources.unshift(root); // inject Percy CSS
+
+  if (snapshot.percyCSS) {
+    let css = (0, _utils2.createPercyCSSResource)(root.url, snapshot.percyCSS);
+    resources.push(css); // replace root contents and associated properties
+
+    Object.assign(root, (0, _utils2.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
+
+
+  resources.push((0, _utils2.createLogResource)(_logger.default.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 callback(snapshot, resources);
+} // Wait for a page's asset discovery network to idle
+
+
+function waitForDiscoveryNetworkIdle(page, options) {
+  let {
+    allowedHostnames,
+    networkIdleTimeout
+  } = options;
+
+  let filter = r => (0, _utils2.hostnameMatches)(allowedHostnames, r.url);
+
+  return page.network.idle(filter, networkIdleTimeout);
+} // Used to cache resources across core instances
+
+
+const RESOURCE_CACHE_KEY = Symbol('resource-cache'); // Discovers resources for a snapshot using a browser page to intercept requests. The callback
+// function will be called with the snapshot name (for additional snapshots) and an array of
+// discovered resources. When additional snapshots are provided, the callback will be called once
+// for each snapshot.
+
+async function* discoverSnapshotResources(percy, snapshot, callback) {
+  var _snapshot$enableJavaS;
+
+  debugSnapshotConfig(snapshot, percy.dryRun); // when dry-running, invoke the callback for each snapshot and immediately return
+
+  let allSnapshots = [snapshot, ...(snapshot.additionalSnapshots || [])];
+  if (percy.dryRun) return allSnapshots.map(s => callback(s)); // keep a global resource cache across snapshots
+
+  let cache = percy[RESOURCE_CACHE_KEY] || (percy[RESOURCE_CACHE_KEY] = new Map()); // copy widths to prevent mutation later
+
+  let widths = snapshot.widths.slice(); // preload the root resource for existing dom snapshots
+
+  let resources = new Map(snapshot.domSnapshot && [(0, _utils2.createRootResource)(snapshot.url, snapshot.domSnapshot)].map(resource => [resource.url, resource])); // open a new browser page
+
+  let page = yield percy.browser.page({
+    enableJavaScript: (_snapshot$enableJavaS = snapshot.enableJavaScript) !== null && _snapshot$enableJavaS !== void 0 ? _snapshot$enableJavaS : !snapshot.domSnapshot,
+    networkIdleTimeout: snapshot.discovery.networkIdleTimeout,
+    requestHeaders: snapshot.discovery.requestHeaders,
+    authorization: snapshot.discovery.authorization,
+    userAgent: snapshot.discovery.userAgent,
+    meta: snapshot.meta,
+    // enable network inteception
+    intercept: {
+      enableJavaScript: snapshot.enableJavaScript,
+      disableCache: snapshot.discovery.disableCache,
+      allowedHostnames: snapshot.discovery.allowedHostnames,
+      getResource: u => resources.get(u) || cache.get(u),
+      saveResource: r => resources.set(r.url, r) && cache.set(r.url, r)
+    }
+  });
+
+  try {
+    var _snapshot$execute;
+
+    // set the initial page size
+    yield page.resize({
+      width: widths.shift(),
+      height: snapshot.minHeight
+    }); // navigate to the url
+
+    yield page.goto(snapshot.url);
+    yield page.evaluate((_snapshot$execute = snapshot.execute) === null || _snapshot$execute === void 0 ? void 0 : _snapshot$execute.afterNavigation); // trigger resize events for other widths
+
+    for (let width of widths) {
+      var _snapshot$execute2, _snapshot$execute3;
+
+      yield page.evaluate((_snapshot$execute2 = snapshot.execute) === null || _snapshot$execute2 === void 0 ? void 0 : _snapshot$execute2.beforeResize);
+      yield waitForDiscoveryNetworkIdle(page, snapshot.discovery);
+      yield page.resize({
+        width,
+        height: snapshot.minHeight
+      });
+      yield page.evaluate((_snapshot$execute3 = snapshot.execute) === null || _snapshot$execute3 === void 0 ? void 0 : _snapshot$execute3.afterResize);
+    }
+
+    if (snapshot.domSnapshot) {
+      // ensure discovery has finished and handle resources
+      yield waitForDiscoveryNetworkIdle(page, snapshot.discovery);
+      handleSnapshotResources(snapshot, resources, callback);
+    } else {
+      // capture snapshots sequentially
+      for (let snap of allSnapshots) {
+        // shallow merge snapshot options
+        let options = { ...snapshot,
+          ...snap
+        }; // will wait for timeouts, selectors, and additional network activity
+
+        let {
+          url,
+          dom
+        } = yield page.snapshot(options); // handle resources and remove previously captured dom snapshots
+
+        resources.set(url, (0, _utils2.createRootResource)(url, dom));
+        handleSnapshotResources(options, resources, callback);
+        resources.delete(url);
+      }
+    } // page clean up
+
+
+    await page.close();
+  } catch (error) {
+    await page.close();
+    throw error;
+  }
+}

package/dist/utils.js

@@ -3,20 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hostname = hostname;
-exports.normalizeURL = normalizeURL;
-exports.createResource = createResource;
-exports.createRootResource = createRootResource;
 exports.createLogResource = createLogResource;
 exports.createPercyCSSResource = createPercyCSSResource;
-exports.injectPercyCSS = injectPercyCSS;
-exports.waitFor = waitFor;
+exports.createResource = createResource;
+exports.createRootResource = createRootResource;
+exports.hostname = hostname;
 Object.defineProperty(exports, "hostnameMatches", {
   enumerable: true,
   get: function () {
     return _utils.hostnameMatches;
   }
 });
+exports.normalizeURL = normalizeURL;
+exports.waitFor = waitFor;
 
 var _utils = require("@percy/client/dist/utils");
 
@@ -53,33 +52,22 @@ function createRootResource(url, content) {
   return createResource(normalizeURL(url), content, 'text/html', {
     root: true
   });
-} // Creates a log resource object.
-
-
-function createLogResource(logs) {
-  return createResource(`/percy.${Date.now()}.log`, JSON.stringify(logs), 'text/plain');
 } // Creates a Percy CSS resource object.
 
 
 function createPercyCSSResource(url, css) {
-  if (css) {
-    let {
-      href,
-      pathname
-    } = new URL(`/percy-specific.${Date.now()}.css`, url);
-    return createResource(href, css, 'text/css', {
-      pathname
-    });
-  }
-} // returns a new root resource with the injected Percy CSS
+  let {
+    href,
+    pathname
+  } = new URL(`/percy-specific.${Date.now()}.css`, url);
+  return createResource(href, css, 'text/css', {
+    pathname
+  });
+} // Creates a log resource object.
 
 
-function injectPercyCSS(root, percyCSS) {
-  if (percyCSS) {
-    return createRootResource(root.url, root.content.replace(/(<\/body>)(?!.*\1)/is, `<link data-percy-specific-css rel="stylesheet" href="${percyCSS.pathname}"/>` + '$&'));
-  } else {
-    return root;
-  }
+function createLogResource(logs) {
+  return createResource(`/percy.${Date.now()}.log`, JSON.stringify(logs), 'text/plain');
 } // Polls for the predicate to be truthy within a timeout or the returned promise rejects. If
 // the second argument is an options object and `idle` is provided, the predicate will be
 // checked again after the idle period. This helper is injected as an argument when using

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.0.0-beta.68",
+  "version": "1.0.0-beta.71",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -25,10 +25,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@percy/client": "1.0.0-beta.68",
-    "@percy/config": "1.0.0-beta.68",
-    "@percy/dom": "1.0.0-beta.68",
-    "@percy/logger": "1.0.0-beta.68",
+    "@percy/client": "1.0.0-beta.71",
+    "@percy/config": "1.0.0-beta.71",
+    "@percy/dom": "1.0.0-beta.71",
+    "@percy/logger": "1.0.0-beta.71",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
     "rimraf": "^3.0.2",
@@ -39,5 +39,5 @@
     "url": "https://github.com/percy/cli",
     "directory": "packages/core"
   },
-  "gitHead": "32ffd12d1db407b7c2b4ca8364f99f90b2cfa862"
+  "gitHead": "364d1df717fb19a26ccb024458df6e78a9c11f99"
 }

package/types/index.d.ts

@@ -44,18 +44,24 @@ export interface SnapshotOptions extends CommonSnapshotOptions {
   discovery?: DiscoveryOptions;
 }
 
-export type PercyOptions<C = Pojo> = C & {
-  token?: string,
+type ClientEnvInfo = {
   clientInfo?: string,
-  environmentInfo?: string,
+  environmentInfo?: string
+}
+
+export type PercyConfigOptions<C = Pojo> = C & {
+  snapshot?: CommonSnapshotOptions,
+  discovery?: AllDiscoveryOptions
+}
+
+export type PercyOptions<C = Pojo> = {
+  token?: string,
   server?: boolean,
   port?: number,
   concurrency?: number,
   loglevel?: LogLevel,
-  config?: undefined | string | false,
-  snapshot?: CommonSnapshotOptions,
-  discovery?: AllDiscoveryOptions
-};
+  config?: undefined | string | false
+} & ClientEnvInfo & PercyConfigOptions<C>;
 
 type SnapshotExec = () => void | Promise<void>;
 
@@ -70,6 +76,8 @@ declare class Percy {
   constructor(options?: PercyOptions);
   loglevel(): LogLevel;
   loglevel(level: LogLevel): void;
+  config: PercyConfigOptions;
+  setConfig(config: ClientEnvInfo & PercyConfigOptions): PercyConfigOptions;
   start(): Promise<void>;
   stop(force?: boolean): Promise<void>;
   idle(): Promise<void>;