@percy/core 1.0.0-beta.70 → 1.0.0-beta.74

package/dist/browser.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Browser = void 0;
 
 var _os = _interopRequireDefault(require("os"));
 
@@ -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; }
@@ -59,14 +63,16 @@ class Browser extends _events.default {
 
     _defineProperty(this, "sessions", new Map());
 
+    _defineProperty(this, "readyState", null);
+
     _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
     });
@@ -74,7 +80,8 @@ class Browser extends _events.default {
     _defineProperty(this, "args", [// disable the translate popup
     '--disable-features=Translate', // disable several subsystems which run network requests in the background
     '--disable-background-networking', // disable task throttling of timer tasks from background pages
-    '--disable-background-timer-throttling', // disable backgrounding renderers for occluded windows (reduce nondeterminism)
+    '--disable-background-timer-throttling', // disable backgrounding renderer processes
+    '--disable-renderer-backgrounding', // disable backgrounding renderers for occluded windows (reduce nondeterminism)
     '--disable-backgrounding-occluded-windows', // disable crash reporting
     '--disable-breakpad', // disable client side phishing detection
     '--disable-client-side-phishing-detection', // disable default component extensions with background pages for performance
@@ -112,7 +119,9 @@ class Browser extends _events.default {
   }
 
   async launch() {
-    if (this.isConnected()) return; // check if any provided executable exists
+    // already launching or launched
+    if (this.readyState != null) return;
+    this.readyState = 0; // check if any provided executable exists
 
     if (this.executable && !(0, _fs.existsSync)(this.executable)) {
       this.log.error(`Browser executable not found: ${this.executable}`);
@@ -122,11 +131,10 @@ class Browser extends _events.default {
 
     this.executable || (this.executable = await _install.default.chromium()); // create a temporary profile directory
 
-    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}`];
-    this.log.debug('Launching browser'); // spawn the browser process detached in its own group and session
+    this.profile = await _fs.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), 'percy-browser-')); // spawn the browser process detached in its own group and session
 
+    let args = this.args.concat(`--user-data-dir=${this.profile}`);
+    this.log.debug('Launching browser');
     this.process = (0, _crossSpawn.default)(this.executable, args, {
       detached: process.platform !== 'win32'
     }); // connect a websocket to the devtools address
@@ -140,7 +148,8 @@ 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}`);
+    this.log.debug(`Browser connected [${this.process.pid}]: ${this.version.product}`);
+    this.readyState = 1;
   }
 
   isConnected() {
@@ -152,7 +161,9 @@ class Browser extends _events.default {
   async close() {
     var _this$process4, _this$ws2;
 
+    // not running, already closed, or closing
     if (this._closed) return this._closed;
+    this.readyState = 2;
     this.log.debug('Closing browser'); // resolves when the browser has closed
 
     this._closed = Promise.all([new Promise(resolve => {
@@ -180,8 +191,9 @@ class Browser extends _events.default {
           this.log.debug(error);
         });
       }
-
+    }).then(() => {
       this.log.debug('Browser closed');
+      this.readyState = 3;
     }); // reject any pending callbacks
 
     for (let callback of _classPrivateFieldGet(this, _callbacks).values()) {
@@ -278,34 +290,28 @@ class Browser extends _events.default {
         let match = chunk.match(/^DevTools listening on (ws:\/\/.*)$/m);
         if (match) cleanup(() => resolve(match[1]));
       };
-      /* istanbul ignore next: for sanity */
 
+      let handleExitClose = () => handleError();
 
-      let handleExit = () => handleError();
+      let handleError = error => cleanup(() => {
+        var _error$message;
 
-      let handleClose = () => handleError();
-
-      let handleError = error => {
-        cleanup(() => {
-          var _error$message;
-
-          return reject(new Error(`Failed to launch browser. ${(_error$message = error === null || error === void 0 ? void 0 : error.message) !== null && _error$message !== void 0 ? _error$message : ''}\n${stderr}'\n\n`));
-        });
-      };
+        return reject(new Error(`Failed to launch browser. ${(_error$message = error === null || error === void 0 ? void 0 : error.message) !== null && _error$message !== void 0 ? _error$message : ''}\n${stderr}'\n\n`));
+      });
 
       let cleanup = callback => {
         clearTimeout(timeoutId);
         this.process.stderr.off('data', handleData);
-        this.process.stderr.off('close', handleClose);
-        this.process.off('exit', handleExit);
+        this.process.stderr.off('close', handleExitClose);
+        this.process.off('exit', handleExitClose);
         this.process.off('error', handleError);
         callback();
       };
 
       let timeoutId = setTimeout(() => handleError(new Error(`Timed out after ${timeout}ms`)), timeout);
       this.process.stderr.on('data', handleData);
-      this.process.stderr.on('close', handleClose);
-      this.process.on('exit', handleExit);
+      this.process.stderr.on('close', handleExitClose);
+      this.process.on('exit', handleExitClose);
       this.process.on('error', handleError);
     }));
     return this._address;
@@ -352,4 +358,6 @@ class Browser extends _events.default {
 
 }
 
-exports.default = Browser;
+exports.Browser = Browser;
+var _default = Browser;
+exports.default = _default;

package/dist/config.js

@@ -296,9 +296,12 @@ const snapshotDOMSchema = {
     // schemas have no concept of inheritance, but we can leverage JS for brevity
     ...snapshotSchema.properties
   }
-}; // Config migrate function
+}; // Grouped schemas for easier registration
 
 exports.snapshotDOMSchema = snapshotDOMSchema;
+const schemas = [configSchema, snapshotSchema, snapshotDOMSchema]; // Config migrate function
+
+exports.schemas = schemas;
 
 function configMigration(config, util) {
   /* eslint-disable curly */
@@ -348,10 +351,8 @@ function snapshotMigration(config, util) {
     map: 'additionalSnapshots',
     ...notice
   });
-} // Convinient references for schema registrations
+} // Grouped migrations for easier registration
 
 
-const schemas = [configSchema, snapshotSchema, snapshotDOMSchema];
-exports.schemas = schemas;
 const migrations = [['/config', configMigration], ['/snapshot', snapshotMigration]];
 exports.migrations = migrations;

package/dist/index.js

@@ -1,13 +1,15 @@
 "use strict";
 
-// Register core config options
-const {
-  default: PercyConfig
-} = require('@percy/config');
+const PercyConfig = require('@percy/config');
 
 const CoreConfig = require('./config');
 
+const {
+  Percy
+} = require('./percy');
+
 PercyConfig.addSchema(CoreConfig.schemas);
-PercyConfig.addMigration(CoreConfig.migrations); // Export the Percy class with commonjs compatibility
+PercyConfig.addMigration(CoreConfig.migrations); // export the Percy class with commonjs compatibility
 
-module.exports = require('./percy').default;
+module.exports = Percy;
+module.exports.Percy = Percy;

package/dist/network.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Network = void 0;
 
 var _logger = _interopRequireDefault(require("@percy/logger"));
 
@@ -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()
     });
@@ -353,6 +357,9 @@ class Network {
 
 }
 
-exports.default = Network;
+exports.Network = Network;
+
+_defineProperty(Network, "TIMEOUT", 30000);
 
-_defineProperty(Network, "TIMEOUT", 30000);
+var _default = Network;
+exports.default = _default;

package/dist/page.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Page = void 0;
 
 var _fs = require("fs");
 
@@ -179,7 +179,14 @@ class Page {
     } // wrap the function body with percy helpers
 
 
-    fnbody = 'function withPercyHelpers() {' + (`return (${fnbody})({` + `waitFor: ${_utils.waitFor}` + '}, ...arguments)') + '}'; // send the call function command
+    fnbody = 'function withPercyHelpers() {\n' + [`return (${fnbody})({ generatePromise, waitFor }, ...arguments);`, `${_utils.generatePromise}`, `${_utils.waitFor}`].join('\n\n') + '}';
+    /* istanbul ignore else: ironic. */
+
+    if (fnbody.includes('cov_')) {
+      // remove coverage statements during testing
+      fnbody = fnbody.replace(/cov_.*?(;\n?|,)\s*/g, '');
+    } // send the call function command
+
 
     let {
       result,
@@ -214,7 +221,7 @@ class Page {
 
     for (let script of scripts) {
       if (typeof script === 'string') {
-        script = `async eval({ waitFor }) {\n${script}\n}`;
+        script = `async eval() {\n${script}\n}`;
       }
 
       await this.eval(script);
@@ -250,7 +257,7 @@ class Page {
     } // execute any javascript
 
 
-    await this.evaluate(typeof execute === 'function' ? execute : execute === null || execute === void 0 ? void 0 : execute.beforeSnapshot); // wait for any final network activity before capturing the dom snapshot
+    await this.evaluate(typeof execute === 'object' && !Array.isArray(execute) ? execute.beforeSnapshot : execute); // wait for any final network activity before capturing the dom snapshot
 
     await this.network.idle(); // inject @percy/dom for serialization by evaluating the file contents which adds a global
     // PercyDOM object that we can later check against
@@ -278,6 +285,9 @@ class Page {
 
 }
 
-exports.default = Page;
+exports.Page = Page;
+
+_defineProperty(Page, "TIMEOUT", 30000);
 
-_defineProperty(Page, "TIMEOUT", 30000);
+var _default = Page;
+exports.default = _default;

package/dist/percy.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Percy = void 0;
 
 var _client = _interopRequireDefault(require("@percy/client"));
 
@@ -21,8 +21,14 @@ var _server = _interopRequireDefault(require("./server"));
 
 var _snapshot = require("./snapshot");
 
+var _utils2 = require("./utils");
+
 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); }
@@ -67,35 +73,198 @@ class Percy {
     port = 5338,
     // options such as `snapshot` and `discovery` that are valid Percy config
     // options which will become accessible via the `.config` property
-    ...options
+    ..._options
   } = {}) {
     _defineProperty(this, "log", (0, _logger.default)('core'));
 
     _defineProperty(this, "readyState", null);
 
-    _uploads.set(this, {
+    _classPrivateFieldInitSpec(this, _uploads, {
       writable: true,
       value: new _queue.default()
     });
 
-    _snapshots.set(this, {
+    _classPrivateFieldInitSpec(this, _snapshots, {
       writable: true,
       value: new _queue.default()
     });
 
+    _defineProperty(this, "idle", () => (0, _utils2.generatePromise)(async function* () {
+      yield* _classPrivateFieldGet(this, _snapshots).idle();
+      yield* _classPrivateFieldGet(this, _uploads).idle();
+    }.bind(this)));
+
+    _defineProperty(this, "start", options => (0, _utils2.generatePromise)(async function* () {
+      // already starting or started
+      if (this.readyState != null) return;
+      this.readyState = 0; // create a percy build as the first immediately queued task
+
+      let buildTask = _classPrivateFieldGet(this, _uploads).push('build/create', () => {
+        // pause other queued tasks until after the build is created
+        _classPrivateFieldGet(this, _uploads).stop();
+
+        return this.client.createBuild().then(({
+          data: {
+            id,
+            attributes
+          }
+        }) => {
+          this.build = {
+            id
+          };
+          this.build.number = attributes['build-number'];
+          this.build.url = attributes['web-url'];
+
+          _classPrivateFieldGet(this, _uploads).run();
+        });
+      }, 0); // handle deferred build errors
+
+
+      if (this.deferUploads) {
+        buildTask.catch(err => {
+          this.log.error('Failed to create build');
+          this.log.error(err);
+          this.close();
+        });
+      }
+
+      try {
+        var _this$server;
+
+        // when not deferred, wait until the build is created first
+        if (!this.deferUploads) await buildTask; // maybe launch the discovery browser
+
+        if (!this.dryRun && (options === null || options === void 0 ? void 0 : options.browser) !== false) {
+          yield this.browser.launch();
+        } // start the server after everything else is ready
+
+
+        yield (_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.listen(this.port); // mark instance as started
+
+        this.log.info('Percy has started!');
+        this.readyState = 1;
+      } catch (error) {
+        var _this$server2;
+
+        // on error, close any running server and browser
+        await ((_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.close());
+        await this.browser.close(); // mark instance as closed
+
+        this.readyState = 3; // when uploads are deferred, cancel build creation
+
+        if (error.canceled && this.deferUploads) {
+          _classPrivateFieldGet(this, _uploads).cancel('build/create');
+
+          this.readyState = null;
+        } // throw an easier-to-understand error when the port is taken
+
+
+        if (error.code === 'EADDRINUSE') {
+          throw new Error('Percy is already running or the port is in use');
+        } else {
+          throw error;
+        }
+      }
+    }.bind(this)));
+
+    _defineProperty(this, "flush", close => (0, _utils2.generatePromise)(async function* () {
+      // close the snapshot queue and wait for it to empty
+      if (_classPrivateFieldGet(this, _snapshots).size) {
+        if (close) _classPrivateFieldGet(this, _snapshots).close();
+        yield* _classPrivateFieldGet(this, _snapshots).flush(s => {
+          // do not log a count when not closing or while dry-running
+          if (!close || this.dryRun) return;
+          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).size) {
+        if (close) _classPrivateFieldGet(this, _uploads).close();
+        yield* _classPrivateFieldGet(this, _uploads).flush(s => {
+          // do not log a count when not closing or while creating a build
+          if (!close || _classPrivateFieldGet(this, _uploads).has('build/create')) return;
+          this.log.progress(`Uploading ${s} snapshot${s !== 1 ? 's' : ''}...`, !!s);
+        });
+      }
+    }.bind(this)).canceled(() => {
+      // reopen closed queues when canceled
+      _classPrivateFieldGet(this, _snapshots).open();
+
+      _classPrivateFieldGet(this, _uploads).open();
+    }));
+
+    _defineProperty(this, "stop", force => (0, _utils2.generatePromise)(async function* () {
+      var _this$server3, _this$build;
+
+      // not started, but the browser was launched
+      if (!this.readyState && this.browser.isConnected()) {
+        await this.browser.close();
+      } // not started or already stopped
+
+
+      if (!this.readyState || this.readyState > 2) return; // close queues asap
+
+      if (force) this.close(); // already stopping
+
+      if (this.readyState === 2) return;
+      this.readyState = 2; // log when force stopping
+
+      if (force) this.log.info('Stopping percy...'); // process uploads and close queues
+
+      yield* this.flush(true); // if dry-running, log the total number of snapshots
+
+      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 any running server and browser
+
+
+      await ((_this$server3 = this.server) === null || _this$server3 === void 0 ? void 0 : _this$server3.close());
+      await this.browser.close(); // finalize and log build info
+
+      let meta = {
+        build: this.build
+      };
+
+      if ((_this$build = this.build) !== null && _this$build !== void 0 && _this$build.failed) {
+        // do not finalize failed builds
+        this.log.warn(`Build #${this.build.number} failed: ${this.build.url}`, meta);
+      } else if (this.build) {
+        // finalize the build
+        await this.client.finalizeBuild(this.build.id);
+        this.log.info(`Finalized build #${this.build.number}: ${this.build.url}`, meta);
+      } else {
+        // no build was ever created (likely failed while deferred)
+        this.log.warn('Build not created', meta);
+      } // mark instance as stopped
+
+
+      this.readyState = 3;
+    }.bind(this)).canceled(() => {
+      // reset ready state when canceled
+      this.readyState = 1;
+    }));
+
     if (loglevel) this.loglevel(loglevel);
     this.dryRun = !!dryRun;
     this.skipUploads = this.dryRun || !!skipUploads;
     this.deferUploads = this.skipUploads || !!deferUploads;
+    if (this.deferUploads) _classPrivateFieldGet(this, _uploads).stop();
     this.config = _config.default.load({
-      overrides: options,
+      overrides: _options,
       path: config
     });
-    let {
-      concurrency
-    } = this.config.discovery;
-    if (concurrency) _classPrivateFieldGet(this, _snapshots).concurrency = concurrency;
-    if (this.deferUploads) _classPrivateFieldGet(this, _uploads).stop();
+
+    if (this.config.discovery.concurrency) {
+      let {
+        concurrency
+      } = this.config.discovery;
+      _classPrivateFieldGet(this, _uploads).concurrency = concurrency;
+      _classPrivateFieldGet(this, _snapshots).concurrency = concurrency;
+    }
+
     this.client = new _client.default({
       token,
       clientInfo,
@@ -147,23 +316,21 @@ class Percy {
     this.config = (0, _utils.merge)([this.config, config], (path, prev, next) => {
       // replace arrays instead of merging
       return Array.isArray(next) && [path, next];
-    });
+    }); // adjust concurrency if necessary
+
+    if (this.config.discovery.concurrency) {
+      let {
+        concurrency
+      } = this.config.discovery;
+      _classPrivateFieldGet(this, _uploads).concurrency = concurrency;
+      _classPrivateFieldGet(this, _snapshots).concurrency = concurrency;
+    }
+
     return this.config;
   } // Resolves once snapshot and upload queues are idle
 
 
-  async idle() {
-    await _classPrivateFieldGet(this, _snapshots).idle();
-    await _classPrivateFieldGet(this, _uploads).idle();
-  } // Waits for snapshot idle and flushes the upload queue
-
-
-  async dispatch() {
-    await _classPrivateFieldGet(this, _snapshots).idle();
-    if (!this.skipUploads) await _classPrivateFieldGet(this, _uploads).flush();
-  } // Immediately stops all queues, preventing any more tasks from running
-
-
+  // Immediately stops all queues, preventing any more tasks from running
   close() {
     _classPrivateFieldGet(this, _snapshots).close(true);
 
@@ -172,124 +339,7 @@ class Percy {
   // at a later time when uploads are deferred, or run immediately when not deferred.
 
 
-  async start() {
-    // already starting or started
-    if (this.readyState != null) return;
-    this.readyState = 0; // create a percy build as the first immediately queued task
-
-    let buildTask = _classPrivateFieldGet(this, _uploads).push('build/create', () => {
-      // pause other queued tasks until after the build is created
-      _classPrivateFieldGet(this, _uploads).stop();
-
-      return this.client.createBuild().then(({
-        data: {
-          id,
-          attributes
-        }
-      }) => {
-        this.build = {
-          id
-        };
-        this.build.number = attributes['build-number'];
-        this.build.url = attributes['web-url'];
-
-        _classPrivateFieldGet(this, _uploads).run();
-      });
-    }, 0); // handle deferred build errors
-
-
-    if (this.deferUploads) {
-      buildTask.catch(err => {
-        this.log.error('Failed to create build');
-        this.log.error(err);
-        this.close();
-      });
-    }
-
-    try {
-      var _this$server;
-
-      // when not deferred, wait until the build is created first
-      if (!this.deferUploads) await buildTask; // launch the discovery browser
-
-      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
-
-      this.log.info('Percy has started!');
-      this.readyState = 1;
-    } catch (error) {
-      var _this$server2;
-
-      // on error, close any running server and browser
-      await ((_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.close());
-      await this.browser.close();
-      this.readyState = 3; // throw an easier-to-understand error when the port is taken
-
-      if (error.code === 'EADDRINUSE') {
-        throw new Error('Percy is already running or the port is in use');
-      } else {
-        throw error;
-      }
-    }
-  } // Stops the local API server and browser once snapshots have completed and finalizes the Percy
-  // build. Does nothing if not running. When `force` is true, any queued tasks are cleared.
-
-
-  async stop(force) {
-    var _this$server3, _this$build;
-
-    // not started or already stopped
-    if (!this.readyState || this.readyState > 2) return; // close queues asap
-
-    if (force) this.close(); // already stopping
-
-    if (this.readyState === 2) return;
-    this.readyState = 2; // log when force stopping
-
-    let meta = {
-      build: this.build
-    };
-    if (force) this.log.info('Stopping percy...', meta); // close the snapshot queue and wait for it to empty
-
-    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().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
-
-
-    await ((_this$server3 = this.server) === null || _this$server3 === void 0 ? void 0 : _this$server3.close());
-    await this.browser.close();
-
-    if ((_this$build = this.build) !== null && _this$build !== void 0 && _this$build.failed) {
-      // do not finalize failed builds
-      this.log.warn(`Build #${this.build.number} failed: ${this.build.url}`, meta);
-    } else if (this.build) {
-      // finalize the build
-      await this.client.finalizeBuild(this.build.id);
-      this.log.info(`Finalized build #${this.build.number}: ${this.build.url}`, meta);
-    } else {
-      // no build was ever created (likely failed while deferred)
-      this.log.warn('Build not created', meta);
-    }
-
-    this.readyState = 3;
-  } // Deprecated capture method
-
-
+  // Deprecated capture method
   capture(options) {
     this.log.deprecated('The #capture() method will be ' + 'removed in 1.0.0. Use #snapshot() instead.');
     return this.snapshot(options);
@@ -324,10 +374,12 @@ class Percy {
         yield* (0, _snapshot.discoverSnapshotResources)(this, snapshot, (snap, resources) => {
           if (!this.dryRun) this.log.info(`Snapshot taken: ${snap.name}`, snap.meta);
 
-          this._scheduleUpload(snap, resources);
+          this._scheduleUpload(snap.name, { ...snap,
+            resources
+          });
         });
       } catch (error) {
-        if (error.message === 'Canceled') {
+        if (error.canceled) {
           this.log.error('Received a duplicate snapshot name, ' + `the previous snapshot was canceled: ${snapshot.name}`);
         } else {
           this.log.error(`Encountered an error taking snapshot: ${snapshot.name}`, snapshot.meta);
@@ -339,15 +391,15 @@ class Percy {
 
       return; // eslint-disable-line no-useless-return
     }.bind(this));
-  } // Queues a snapshot upload with the provided configuration options and resources
+  } // Queues a snapshot upload with the provided options
 
 
-  _scheduleUpload(snapshot, resources) {
-    _classPrivateFieldGet(this, _uploads).push(`upload/${snapshot.name}`, async () => {
+  _scheduleUpload(name, options) {
+    return _classPrivateFieldGet(this, _uploads).push(`upload/${name}`, async () => {
       try {
-        await this.client.sendSnapshot(this.build.id, { ...snapshot,
-          resources
-        });
+        /* istanbul ignore if: useful for other internal packages */
+        if (typeof options === 'function') options = await options();
+        await this.client.sendSnapshot(this.build.id, options);
       } catch (error) {
         var _error$response, _failed$detail;
 
@@ -356,8 +408,8 @@ class Percy {
 
           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: ${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
+        this.log.error(`Encountered an error uploading snapshot: ${name}`, options.meta);
+        this.log.error((_failed$detail = failed === null || failed === void 0 ? void 0 : failed.detail) !== null && _failed$detail !== void 0 ? _failed$detail : error, options.meta); // build failed at some point, stop accepting snapshots
 
         if (failed) {
           this.build.failed = true;
@@ -369,4 +421,6 @@ class Percy {
 
 }
 
-exports.default = Percy;
+exports.Percy = Percy;
+var _default = Percy;
+exports.default = _default;

package/dist/queue.js

@@ -3,10 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Queue = 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,19 +19,6 @@ 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();
@@ -38,12 +29,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()
     });
@@ -52,7 +43,10 @@ class Queue {
   }
 
   push(id, callback, priority) {
-    if (this.closed) throw new Error('Closed');
+    if (this.closed && !id.startsWith('@@/')) {
+      throw new Error('Closed');
+    }
+
     this.cancel(id);
     let task = {
       id,
@@ -73,15 +67,19 @@ class Queue {
   }
 
   cancel(id) {
-    let pending = _classPrivateFieldGet(this, _pending).get(id);
+    var _classPrivateFieldGet2, _classPrivateFieldGet3;
 
-    if (pending) pending.canceled = true;
+    (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _pending).get(id)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : (_classPrivateFieldGet3 = _classPrivateFieldGet2.cancel) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.call(_classPrivateFieldGet2);
 
     _classPrivateFieldGet(this, _pending).delete(id);
 
     _classPrivateFieldGet(this, _queued).delete(id);
   }
 
+  has(id) {
+    return _classPrivateFieldGet(this, _queued).has(id) || _classPrivateFieldGet(this, _pending).has(id);
+  }
+
   clear() {
     _classPrivateFieldGet(this, _queued).clear();
 
@@ -105,32 +103,48 @@ class Queue {
     return this;
   }
 
+  open() {
+    this.closed = false;
+    return this;
+  }
+
   close(abort) {
     if (abort) this.stop().clear();
     this.closed = true;
     return this;
   }
 
-  async idle() {
-    await (0, _utils.waitFor)(() => {
+  idle(callback) {
+    return (0, _utils.waitFor)(() => {
+      callback === null || callback === void 0 ? void 0 : callback(_classPrivateFieldGet(this, _pending).size);
       return !_classPrivateFieldGet(this, _pending).size;
     }, {
       idle: 10
     });
   }
 
-  async empty(onCheck) {
-    await (0, _utils.waitFor)(() => {
-      onCheck === null || onCheck === void 0 ? void 0 : onCheck(this.size);
+  empty(callback) {
+    return (0, _utils.waitFor)(() => {
+      callback === null || callback === void 0 ? void 0 : callback(this.size);
       return !this.size;
     }, {
       idle: 10
     });
   }
 
-  async flush() {
-    this.push('@@/flush', () => this.stop());
-    await this.run().idle();
+  flush(callback) {
+    let stopped = !this.running;
+    this.run().push('@@/flush', () => {
+      if (stopped) this.stop();
+    });
+    return this.idle(pend => {
+      let left = [..._classPrivateFieldGet(this, _queued).keys()].indexOf('@@/flush');
+      if (!~left && !_classPrivateFieldGet(this, _pending).has('@@/flush')) left = 0;
+      callback === null || callback === void 0 ? void 0 : callback(pend + left);
+    }).canceled(() => {
+      if (stopped) this.stop();
+      this.cancel('@@/flush');
+    });
   }
 
   next() {
@@ -154,27 +168,29 @@ class Queue {
 
     _classPrivateFieldGet(this, _pending).set(task.id, task);
 
-    let done = (callback, arg) => {
-      if (!task.canceled) _classPrivateFieldGet(this, _pending).delete(task.id);
+    let done = callback => arg => {
+      var _task$cancel;
+
+      if (!((_task$cancel = task.cancel) !== null && _task$cancel !== void 0 && _task$cancel.triggered)) {
+        _classPrivateFieldGet(this, _pending).delete(task.id);
+      }
+
       callback(arg);
 
       this._dequeue();
     };
 
     try {
-      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));
+      let gen = (0, _utils.generatePromise)(task.callback);
+      task.cancel = gen.cancel;
+      return gen.then(done(task.resolve), done(task.reject));
     } catch (err) {
-      done(task.reject, err);
+      done(task.reject)(err);
     }
   }
 
 }
 
-exports.default = Queue;
+exports.Queue = Queue;
+var _default = Queue;
+exports.default = _default;

package/dist/server.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createPercyServer = createPercyServer;
 exports.createServer = createServer;
-exports.default = createPercyServer;
+exports.default = void 0;
 
 var _fs = _interopRequireDefault(require("fs"));
 
@@ -155,9 +156,12 @@ function createPercyServer(percy) {
       }];
     },
     // stops the instance async at the end of the event loop
-    '/percy/stop': () => setImmediate(() => percy.stop()) && [200, 'application/json', {
-      success: true
-    }],
+    '/percy/stop': () => {
+      setImmediate(async () => await percy.stop());
+      return [200, 'application/json', {
+        success: true
+      }];
+    },
     // other routes 404
     default: () => [404, 'application/json', {
       error: 'Not found',
@@ -185,4 +189,7 @@ function createPercyServer(percy) {
     });
   });
   return context;
-}
+}
+
+var _default = createPercyServer;
+exports.default = _default;

package/dist/session.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.Session = void 0;
 
 var _events = _interopRequireDefault(require("events"));
 
@@ -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()
     });
@@ -131,4 +135,6 @@ class Session extends _events.default {
 
 }
 
-exports.default = Session;
+exports.Session = Session;
+var _default = Session;
+exports.default = _default;

package/dist/snapshot.js

@@ -63,6 +63,7 @@ function getSnapshotConfig(percy, options) {
     // 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,
@@ -246,20 +247,25 @@ async function* discoverSnapshotResources(percy, snapshot, callback) {
       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 {
+        enableJavaScript
+      } = snapshot; // capture snapshots sequentially
 
+      for (let snap of allSnapshots) {
+        // will wait for timeouts, selectors, and additional network activity
         let {
           url,
           dom
-        } = yield page.snapshot(options); // handle resources and remove previously captured dom snapshots
+        } = yield page.snapshot({
+          enableJavaScript,
+          ...snap
+        });
+        resources.set(url, (0, _utils2.createRootResource)(url, dom)); // shallow merge with root snapshot options
+
+        handleSnapshotResources({ ...snapshot,
+          ...snap
+        }, resources, callback); // remove the previously captured dom snapshot
 
-        resources.set(url, (0, _utils2.createRootResource)(url, dom));
-        handleSnapshotResources(options, resources, callback);
         resources.delete(url);
       }
     } // page clean up

package/dist/utils.js

@@ -7,6 +7,7 @@ exports.createLogResource = createLogResource;
 exports.createPercyCSSResource = createPercyCSSResource;
 exports.createResource = createResource;
 exports.createRootResource = createRootResource;
+exports.generatePromise = generatePromise;
 exports.hostname = hostname;
 Object.defineProperty(exports, "hostnameMatches", {
   enumerable: true,
@@ -15,10 +16,20 @@ Object.defineProperty(exports, "hostnameMatches", {
   }
 });
 exports.normalizeURL = normalizeURL;
+Object.defineProperty(exports, "request", {
+  enumerable: true,
+  get: function () {
+    return _request.request;
+  }
+});
 exports.waitFor = waitFor;
 
 var _utils = require("@percy/client/dist/utils");
 
+var _request = require("@percy/client/dist/request");
+
+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; }
+
 // Returns the hostname portion of a URL.
 function hostname(url) {
   return new URL(url).hostname;
@@ -68,39 +79,92 @@ function createPercyCSSResource(url, css) {
 
 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
-// the `page#eval()` method, such as for the snapshot `execute` option.
+} // Creates a thennable, cancelable, generator instance
+
+
+function generatePromise(gen) {
+  var _gen, _gen2;
+
+  // ensure a generator is provided
+  if (typeof gen === 'function') gen = gen();
+  if (typeof ((_gen = gen) === null || _gen === void 0 ? void 0 : _gen.then) === 'function') return gen;
+  if (typeof ((_gen2 = gen) === null || _gen2 === void 0 ? void 0 : _gen2.next) !== 'function' || !(typeof gen[Symbol.iterator] === 'function' || typeof gen[Symbol.asyncIterator] === 'function')) return Promise.resolve(gen); // used to trigger cancelation
+
+  class Canceled extends Error {
+    constructor(...args) {
+      super(...args);
+
+      _defineProperty(this, "name", 'Canceled');
 
-/* istanbul ignore next: no instrumenting injected code */
+      _defineProperty(this, "canceled", true);
+    }
 
+  } // recursively runs the generator, maybe throwing an error when canceled
 
-function waitFor(predicate, timeoutOrOptions) {
+
+  let handleNext = async (g, last) => {
+    let canceled = g.cancel.triggered;
+    let {
+      done,
+      value
+    } = canceled ? await g.throw(canceled) : await g.next(last);
+    if (canceled) delete g.cancel.triggered;
+    return done ? value : handleNext(g, value);
+  }; // handle cancelation errors by calling any cancel handlers
+
+
+  let cancelable = async function* () {
+    try {
+      return yield* gen;
+    } catch (error) {
+      if (error.canceled) {
+        let cancelers = cancelable.cancelers || [];
+
+        for (let c of cancelers) await c(error);
+      }
+
+      throw error;
+    }
+  }(); // augment the cancelable generator with promise-like and cancel methods
+
+
+  return Object.assign(cancelable, {
+    run: () => cancelable.promise || (cancelable.promise = handleNext(cancelable)),
+    then: (resolve, reject) => cancelable.run().then(resolve, reject),
+    catch: reject => cancelable.run().catch(reject),
+    cancel: message => {
+      cancelable.cancel.triggered = new Canceled(message);
+      return cancelable;
+    },
+    canceled: handler => {
+      (cancelable.cancelers || (cancelable.cancelers = [])).push(handler);
+      return cancelable;
+    }
+  });
+} // Resolves when the predicate function returns true within the timeout. If an idle option is
+// provided, the predicate will be checked again before resolving, after the idle period. The poll
+// option determines how often the predicate check will be run.
+
+
+function waitFor(predicate, options) {
   let {
     poll = 10,
     timeout,
     idle
-  } = Number.isInteger(timeoutOrOptions) ? {
-    timeout: timeoutOrOptions
-  } : timeoutOrOptions || {};
-  return new Promise((resolve, reject) => {
-    return function check(start, done) {
-      try {
-        if (timeout && Date.now() - start >= timeout) {
-          throw new Error(`Timeout of ${timeout}ms exceeded.`);
-        } else if (predicate()) {
-          if (idle && !done) {
-            setTimeout(check, idle, start, true);
-          } else {
-            resolve();
-          }
-        } else {
-          setTimeout(check, poll, start);
-        }
-      } catch (error) {
-        reject(error);
+  } = Number.isInteger(options) ? {
+    timeout: options
+  } : options || {};
+  return generatePromise(async function* check(start, done) {
+    while (true) {
+      if (timeout && Date.now() - start >= timeout) {
+        throw new Error(`Timeout of ${timeout}ms exceeded.`);
+      } else if (!predicate()) {
+        yield new Promise(r => setTimeout(r, poll, done = false));
+      } else if (idle && !done) {
+        yield new Promise(r => setTimeout(r, idle, done = true));
+      } else {
+        return;
       }
-    }(Date.now());
-  });
+    }
+  }(Date.now()));
 }

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "@percy/core",
-  "version": "1.0.0-beta.70",
+  "version": "1.0.0-beta.74",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "dist/index.js",
   "types": "types/index.d.ts",
   "files": [
@@ -21,23 +29,15 @@
     "test:coverage": "yarn test --coverage",
     "test:types": "tsd"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@percy/client": "1.0.0-beta.70",
-    "@percy/config": "1.0.0-beta.70",
-    "@percy/dom": "1.0.0-beta.70",
-    "@percy/logger": "1.0.0-beta.70",
+    "@percy/client": "1.0.0-beta.74",
+    "@percy/config": "1.0.0-beta.74",
+    "@percy/dom": "1.0.0-beta.74",
+    "@percy/logger": "1.0.0-beta.74",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/percy/cli",
-    "directory": "packages/core"
-  },
-  "gitHead": "34f37a98ff71281cebadd39e53bb55a65b0d3456"
+  "gitHead": "f8d1e38e93e5d731b8519d3fa8637e8a478efcde"
 }

package/test/helpers/server.js

@@ -1,7 +1,7 @@
 // aliased to src for coverage during tests without needing to compile this file
 const { createServer } = require('@percy/core/dist/server');
 
-module.exports = function createTestServer(routes, port = 8000) {
+function createTestServer(routes, port = 8000) {
   let context = createServer(routes);
 
   // handle route errors
@@ -16,3 +16,7 @@ module.exports = function createTestServer(routes, port = 8000) {
   // automatically listen
   return context.listen(port);
 };
+
+// support commonjs environments
+module.exports = createTestServer;
+module.exports.createTestServer = createTestServer;