@percy/core 1.0.0-beta.8 → 1.0.1

package/dist/percy.js

@@ -1,55 +1,21 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _client = _interopRequireDefault(require("@percy/client"));
-
-var _config = _interopRequireDefault(require("@percy/config"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _config2 = require("./config");
-
-var _discoverer = _interopRequireDefault(require("./discoverer"));
-
-var _percyCss = _interopRequireDefault(require("./percy-css"));
-
-var _server = require("./server");
-
-var _queue = _interopRequireDefault(require("./queue"));
-
-var _assert = _interopRequireDefault(require("./utils/assert"));
-
-var _resources = require("./utils/resources");
-
-var _url = require("./utils/url");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; }
-
-// Register core config options
-_config.default.addSchema(_config2.schema); // A Percy instance will create a new build when started, handle snapshot
+import PercyClient from '@percy/client';
+import PercyConfig from '@percy/config';
+import logger from '@percy/logger';
+import Queue from './queue.js';
+import Browser from './browser.js';
+import { createPercyServer, createStaticServer } from './api.js';
+import { gatherSnapshots, validateSnapshotOptions, discoverSnapshotResources } from './snapshot.js';
+import { generatePromise } from './utils.js'; // A Percy instance will create a new build when started, handle snapshot
 // creation, asset discovery, and resource uploads, and will finalize the build
 // when stopped. Snapshots are processed concurrently and the build is not
 // finalized until all snapshots have been handled.
 
+export class Percy {
+  log = logger('core');
+  readyState = null;
+  #uploads = new Queue();
+  #snapshots = new Queue(); // Static shortcut to create and start an instance in one call
 
-var _captures = new WeakMap();
-
-var _snapshots = new WeakMap();
-
-var _stopping = new WeakMap();
-
-var _running = new WeakMap();
-
-class Percy {
-  // Static shortcut to create and start an instance in one call
   static async start(options) {
     let instance = new this(options);
     await instance.start();
@@ -57,6 +23,16 @@ class Percy {
   }
 
   constructor({
+    // initial log level
+    loglevel,
+    // do not eagerly upload snapshots
+    deferUploads,
+    // run without uploading anything
+    skipUploads,
+    // implies `skipUploads` and also skips asset discovery
+    dryRun,
+    // configuration filepath
+    config,
     // provided to @percy/client
     token,
     clientInfo = '',
@@ -64,106 +40,178 @@ class Percy {
     // snapshot server options
     server = true,
     port = 5338,
-    // capture concurrency
-    concurrency = 5,
-    // initial log level
-    loglevel,
-    // configuration filepath
-    config,
     // options such as `snapshot` and `discovery` that are valid Percy config
-    // options which will become accessible via the `#config` property
+    // options which will become accessible via the `.config` property
     ...options
   } = {}) {
-    _captures.set(this, {
-      writable: true,
-      value: null
+    if (loglevel) this.loglevel(loglevel);
+    this.dryRun = !!dryRun;
+    this.skipUploads = this.dryRun || !!skipUploads;
+    this.deferUploads = this.skipUploads || !!deferUploads;
+    if (this.deferUploads) this.#uploads.stop();
+    this.config = PercyConfig.load({
+      overrides: options,
+      path: config
     });
 
-    _snapshots.set(this, {
-      writable: true,
-      value: null
-    });
+    if (this.config.discovery.concurrency) {
+      let {
+        concurrency
+      } = this.config.discovery;
+      this.#uploads.concurrency = concurrency;
+      this.#snapshots.concurrency = concurrency;
+    }
 
-    _stopping.set(this, {
-      writable: true,
-      value: false
+    this.client = new PercyClient({
+      token,
+      clientInfo,
+      environmentInfo
     });
-
-    _running.set(this, {
-      writable: true,
-      value: false
+    this.browser = new Browser({ ...this.config.discovery.launchOptions,
+      cookies: this.config.discovery.cookies
     });
 
-    if (loglevel) {
-      this.loglevel(loglevel);
-    }
-
     if (server) {
-      this.port = port;
-      this.app = (0, _server.createServerApp)(this);
-    }
+      this.server = createPercyServer(this, port);
+    } // generator methods are wrapped to autorun and return promises
 
-    _classPrivateFieldSet(this, _snapshots, new _queue.default());
 
-    _classPrivateFieldSet(this, _captures, new _queue.default(concurrency));
+    for (let m of ['start', 'stop', 'flush', 'idle', 'snapshot']) {
+      // the original generator can be referenced with percy.yield.<method>
+      let method = (this.yield || (this.yield = {}))[m] = this[m].bind(this);
 
-    this.config = config === false ? _config.default.getDefaults(options) : _config.default.load({
-      path: config,
-      overrides: options
-    });
-    this.discoverer = new _discoverer.default(this.config.discovery);
-    this.client = new _client.default({
-      token,
-      clientInfo,
-      environmentInfo
-    });
+      this[m] = (...args) => generatePromise(method(...args)).then();
+    }
   } // Shortcut for controlling the global logger's log level.
 
 
   loglevel(level) {
-    return _logger.default.loglevel(level);
-  } // Returns a boolean indicating if this instance is running.
+    return logger.loglevel(level);
+  } // Snapshot server API address
 
 
-  isRunning() {
-    return _classPrivateFieldGet(this, _running);
-  } // Starts the local API server, the asset discovery process, and creates a new
-  // Percy build. When an error is encountered, the discoverer and server are closed.
+  address() {
+    var _this$server;
 
+    return (_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.address();
+  } // Set client & environment info, and override loaded config options
 
-  async start() {
-    // throws when the token is missing
-    this.client.getToken();
 
-    try {
-      // if there is an exress app, a server should be started
-      if (this.app) {
-        this.server = await (0, _server.startServer)(this.app, this.port);
-      } // launch the discoverer browser and create a percy build
+  setConfig({
+    clientInfo,
+    environmentInfo,
+    ...config
+  }) {
+    this.client.addClientInfo(clientInfo);
+    this.client.addEnvironmentInfo(environmentInfo); // normalize config and do nothing if empty
+
+    config = PercyConfig.normalize(config, {
+      schema: '/config'
+    });
+    if (!config) return this.config; // validate provided config options
+
+    let errors = PercyConfig.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 = PercyConfig.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;
+      this.#uploads.concurrency = concurrency;
+      this.#snapshots.concurrency = concurrency;
+    }
 
+    return this.config;
+  } // Resolves once snapshot and upload queues are idle
 
-      await this.discoverer.launch();
-      await this.client.createBuild(); // log build details
 
-      let build = this.client.build;
-      let meta = {
-        build: {
-          id: build.id
+  async *idle() {
+    yield* this.#snapshots.idle();
+    yield* this.#uploads.idle();
+  } // Immediately stops all queues, preventing any more tasks from running
+
+
+  close() {
+    this.#snapshots.close(true);
+    this.#uploads.close(true);
+  } // Starts a local API server, a browser process, and queues creating a new Percy build which will run
+  // at a later time when uploads are deferred, or run immediately when not deferred.
+
+
+  async *start(options) {
+    // already starting or started
+    if (this.readyState != null) return;
+    this.readyState = 0; // create a percy build as the first immediately queued task
+
+    let buildTask = this.#uploads.push('build/create', () => {
+      // pause other queued tasks until after the build is created
+      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'];
+        this.#uploads.run();
+      });
+    }, 0); // handle deferred build errors
+
+    if (this.deferUploads) {
+      buildTask.catch(err => {
+        this.build = {
+          error: 'Failed to create build'
+        };
+        this.log.error(this.build.error);
+        this.log.error(err);
+        this.close();
+      });
+    }
 
-      _logger.default.info('Percy has started!', meta);
+    try {
+      var _this$server2;
 
-      _logger.default.info(`Created build #${build.number}: ${build.url}`, meta); // mark this process as running
+      // 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
 
-      _classPrivateFieldSet(this, _running, true);
+
+      yield (_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.listen(); // mark instance as started
+
+      this.log.info('Percy has started!');
+      this.readyState = 1;
     } catch (error) {
-      var _this$server;
+      var _this$server3;
+
+      // on error, 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(); // mark instance as closed
+
+      this.readyState = 3; // when uploads are deferred, cancel build creation
+
+      if (error.canceled && this.deferUploads) {
+        this.#uploads.cancel('build/create');
+        this.readyState = null;
+      } // throw an easier-to-understand error when the port is taken
 
-      // on error, close any running browser or server
-      await this.discoverer.close();
-      (_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.close(); // 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');
@@ -171,247 +219,266 @@ class Percy {
         throw error;
       }
     }
-  } // Stops the local API server and discoverer once snapshots have completed and
-  // finalizes the Percy build. Does nothing if not running.
+  } // Wait for currently queued snapshots then run and wait for resulting uploads
 
 
-  async stop() {
-    // do nothing if not running or already stopping
-    if (this.isRunning() && !_classPrivateFieldGet(this, _stopping)) {
-      var _this$server2;
-
-      _classPrivateFieldSet(this, _stopping, true);
-
-      let build = this.client.build;
-      let meta = {
-        build: {
-          id: build.id
+  async *flush(close) {
+    try {
+      // wait until the next event loop for synchronous snapshots
+      yield new Promise(r => setImmediate(r)); // close the snapshot queue and wait for it to empty
+
+      if (this.#snapshots.size) {
+        if (close) this.#snapshots.close();
+        yield* 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 && this.#uploads.size) {
+        if (close) this.#uploads.close(); // prevent creating an empty build when deferred
+
+        if (!this.deferUploads || !this.#uploads.has('build/create') || this.#uploads.size > 1) {
+          yield* this.#uploads.flush(s => {
+            // do not log a count when not closing or while creating a build
+            if (!close || this.#uploads.has('build/create')) return;
+            this.log.progress(`Uploading ${s} snapshot${s !== 1 ? 's' : ''}...`, !!s);
+          });
         }
-      };
+      }
+    } catch (error) {
+      // reopen closed queues when canceled
 
-      _logger.default.info('Stopping percy...', meta); // log about queued captures or uploads
+      /* istanbul ignore else: all errors bubble */
+      if (close && error.canceled) {
+        this.#snapshots.open();
+        this.#uploads.open();
+      }
 
+      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.
 
-      if (_classPrivateFieldGet(this, _captures).length) {
-        _logger.default.info(`Waiting for ${_classPrivateFieldGet(this, _captures).length} page(s) to finish snapshotting`, meta);
-      } else if (_classPrivateFieldGet(this, _snapshots).length) {
-        _logger.default.info(`Waiting for ${_classPrivateFieldGet(this, _snapshots).length} snapshot(s) to finish uploading`, meta);
-      } // wait for any queued captures or snapshots
 
+  async *stop(force) {
+    var _this$server4, _this$build, _this$build2;
 
-      await this.idle(); // close the server and browser
+    // not started, but the browser was launched
+    if (!this.readyState && this.browser.isConnected()) {
+      await this.browser.close();
+    } // not started or already stopped
 
-      (_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.close();
-      await this.discoverer.close();
 
-      _classPrivateFieldSet(this, _running, false); // log build info
+    if (!this.readyState || this.readyState > 2) return; // close queues asap
 
+    if (force) this.close(); // already stopping
 
-      await this.client.finalizeBuild();
+    if (this.readyState === 2) return;
+    this.readyState = 2; // log when force stopping
 
-      _logger.default.info(`Finalized build #${build.number}: ${build.url}`, meta);
+    if (force) this.log.info('Stopping percy...');
 
-      _logger.default.info('Done!');
-    }
-  } // Resolves when captures and snapshots are idle.
-
-
-  async idle() {
-    await Promise.all([_classPrivateFieldGet(this, _captures).idle(), _classPrivateFieldGet(this, _snapshots).idle()]);
-  } // Handles asset discovery for the URL and DOM snapshot at each requested
-  // width with the provided options. Resolves when the snapshot has been taken
-  // and asset discovery is finished, but does not gaurantee that the snapshot
-  // will be succesfully uploaded.
-
-
-  snapshot({
-    url,
-    name,
-    domSnapshot,
-    widths,
-    minHeight,
-    percyCSS,
-    requestHeaders,
-    enableJavaScript,
-    clientInfo,
-    environmentInfo
-  }) {
-    var _widths, _widths2, _minHeight, _ref, _enableJavaScript;
-
-    // required assertions
-    (0, _assert.default)(this.isRunning(), 'Not running');
-    (0, _assert.default)(url, 'Missing required argument: url');
-    (0, _assert.default)(name, 'Missing required argument: name');
-    (0, _assert.default)(domSnapshot, 'Missing required argument: domSnapshot'); // fallback to instance snapshot widths
+    try {
+      // process uploads and close queues
+      yield* this.yield.flush(true);
+    } catch (error) {
+      // reset ready state when canceled
 
-    widths = ((_widths = widths) === null || _widths === void 0 ? void 0 : _widths.length) ? widths : this.config.snapshot.widths;
-    (0, _assert.default)((_widths2 = widths) === null || _widths2 === void 0 ? void 0 : _widths2.length, 'Missing required argument: widths');
-    (0, _assert.default)(widths.length <= 10, 'too many widths'); // normalize the URL
+      /* istanbul ignore else: all errors bubble */
+      if (error.canceled) this.readyState = 1;
+      throw error;
+    } // if dry-running, log the total number of snapshots
 
-    url = (0, _url.normalizeURL)(url); // fallback to instance minimum height
 
-    minHeight = (_minHeight = minHeight) !== null && _minHeight !== void 0 ? _minHeight : this.config.snapshot.minHeight; // combine snapshot Percy CSS with instance Percy CSS
+    if (this.dryRun && this.#uploads.size) {
+      let total = this.#uploads.size - 1; // subtract the build task
 
-    percyCSS = [this.config.snapshot.percyCSS, percyCSS].filter(Boolean).join('\n'); // combine snapshot request headers with instance request headers
+      this.log.info(`Found ${total} snapshot${total !== 1 ? 's' : ''}`);
+    } // close any running server and browser
 
-    requestHeaders = { ...this.config.snapshot.requestHeaders,
-      ...requestHeaders
-    }; // fallback to instance enable JS flag
 
-    enableJavaScript = (_ref = (_enableJavaScript = enableJavaScript) !== null && _enableJavaScript !== void 0 ? _enableJavaScript : this.config.snapshot.enableJavaScript) !== null && _ref !== void 0 ? _ref : false; // useful meta info for the logfile
+    await ((_this$server4 = this.server) === null || _this$server4 === void 0 ? void 0 : _this$server4.close());
+    await this.browser.close(); // finalize and log build info
 
     let meta = {
-      snapshot: {
-        name
-      },
-      build: {
-        id: this.client.build.id
-      }
+      build: this.build
     };
 
-    _logger.default.debug('---------');
-
-    _logger.default.debug('Handling snapshot:', meta);
+    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$build2 = this.build) !== null && _this$build2 !== void 0 && _this$build2.id) {
+      // 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;
+  } // 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);
+  } // Takes one or more snapshots of a page while discovering resources to upload with the
+  // snapshot. Once asset discovery has completed, the queued snapshot will resolve and an upload
+  // task will be queued separately. Accepts several different syntaxes for taking snapshots using
+  // various methods.
+  //
+  // snapshot(url|{url}|[...url|{url}])
+  // - requires fully qualified resolvable urls
+  // - snapshot options may be provided with the object syntax
+  //
+  // snapshot({snapshots:[...url|{url}]})
+  // - optional `baseUrl` prepended to snapshot urls
+  // - optional `options` apply to all or specific snapshots
+  //
+  // snapshot(sitemap|{sitemap})
+  // - required to be a fully qualified resolvable url ending in `.xml`
+  // - optional `include`/`exclude` to filter snapshots
+  // - optional `options` apply to all or specific snapshots
+  //
+  // snapshot({serve})
+  // - server address is prepended to snapshot urls
+  // - optional `baseUrl` used when serving pages
+  // - optional `rewrites`/`cleanUrls` to control snapshot urls
+  // - optional `include`/`exclude` to filter snapshots
+  // - optional `snapshots`, with fallback to built-in sitemap.xml
+  // - optional `options` apply to all or specific snapshots
+  //
+  // All available syntaxes will eventually push snapshots to the snapshot queue without the need to
+  // await on this method directly. This method resolves after the snapshot upload is queued, but
+  // does not await on the upload to complete.
+
+
+  snapshot(options) {
+    var _this$build3;
+
+    if (this.readyState !== 1) {
+      throw new Error('Not running');
+    } else if ((_this$build3 = this.build) !== null && _this$build3 !== void 0 && _this$build3.error) {
+      throw new Error(this.build.error);
+    } else if (Array.isArray(options)) {
+      return Promise.all(options.map(o => this.snapshot(o)));
+    }
 
-    _logger.default.debug(`-> name: ${name}`, meta);
+    if (typeof options === 'string') {
+      options = options.endsWith('.xml') ? {
+        sitemap: options
+      } : {
+        url: options
+      };
+    } // validate options and add client & environment info
 
-    _logger.default.debug(`-> url: ${url}`, meta);
 
-    _logger.default.debug(`-> widths: ${widths.join('px, ')}px`, meta);
+    options = validateSnapshotOptions(options);
+    this.client.addClientInfo(options.clientInfo);
+    this.client.addEnvironmentInfo(options.environmentInfo); // return an async generator to allow cancelation
 
-    _logger.default.debug(`-> clientInfo: ${clientInfo}`, meta);
+    return async function* () {
+      let server = 'serve' in options ? await createStaticServer(options).listen() : null;
 
-    _logger.default.debug(`-> environmentInfo: ${environmentInfo}`, meta);
+      try {
+        if (server) {
+          // automatically set specific static server options
+          options.baseUrl = new URL(options.baseUrl || '', server.address()).href;
+          if (!options.snapshots) options.sitemap = new URL('sitemap.xml', options.baseUrl).href;
+        } // gather snapshots from options
 
-    _logger.default.debug(`-> requestHeaders: ${JSON.stringify(requestHeaders)}`, meta);
 
-    _logger.default.debug(`-> domSnapshot:\n${domSnapshot.length <= 1024 ? domSnapshot : domSnapshot.substr(0, 1024) + '... [truncated]'}`, meta); // use a promise as a try-catch so we can do the remaining work
-    // asynchronously, but perform the above synchronously
+        let snapshots = yield gatherSnapshots(this, options);
 
+        try {
+          // yield each task individually to allow canceling
+          let tasks = snapshots.map(s => this._takeSnapshot(s));
 
-    return Promise.resolve().then(async () => {
-      // inject Percy CSS
-      let [percyDOM, percyCSSResource] = (0, _percyCss.default)(url, domSnapshot, percyCSS, meta); // use a map so resources remain unique by url
+          for (let task of tasks) yield task;
+        } catch (error) {
+          // cancel queued snapshots that may not have started
+          snapshots.map(s => this._cancelSnapshot(s));
+          throw error;
+        }
+      } finally {
+        await (server === null || server === void 0 ? void 0 : server.close());
+      }
+    }.call(this);
+  } // Cancel any pending snapshot or snapshot uploads
 
-      let resources = new Map([[url, (0, _resources.createRootResource)(url, percyDOM)]]); // include the Percy CSS resource if there was one
 
-      if (percyCSSResource) resources.set('percy-css', percyCSSResource); // gather resources at each width concurrently
+  _cancelSnapshot(snapshot) {
+    this.#snapshots.cancel(`snapshot/${snapshot.name}`);
 
-      await Promise.all(widths.map(width => this.discoverer.gatherResources(resources, {
-        rootUrl: url,
-        rootDom: domSnapshot,
-        enableJavaScript,
-        requestHeaders,
-        width,
-        meta
-      }))); // include a log resource for debugging
+    for (let {
+      name
+    } of [snapshot, ...(snapshot.additionalSnapshots || [])]) {
+      this.#uploads.cancel(`upload/${name}`);
+    }
+  } // Resolves after asset discovery has finished and uploads have been queued
 
-      let logs = await _logger.default.query({
-        filter: ({
-          snapshot: s
-        }) => (s === null || s === void 0 ? void 0 : s.name) === name
-      });
-      resources.set('percy-logs', (0, _resources.createLogResource)(logs)); // log that the snapshot has been taken before uploading it
 
-      _logger.default.info(`Snapshot taken: ${name}`, meta); // upload within the async snapshot queue
+  _takeSnapshot(snapshot) {
+    // cancel any existing snapshot with the same name
+    this._cancelSnapshot(snapshot);
 
+    return this.#snapshots.push(`snapshot/${snapshot.name}`, async function* () {
+      try {
+        yield* discoverSnapshotResources(this, snapshot, (snap, resources) => {
+          if (!this.dryRun) this.log.info(`Snapshot taken: ${snap.name}`, snap.meta);
 
-      _classPrivateFieldGet(this, _snapshots).push(() => this.client.sendSnapshot({
-        name,
-        widths,
-        minHeight,
-        enableJavaScript,
-        clientInfo,
-        environmentInfo,
-        resources: Array.from(resources.values())
-      }).catch(error => {
-        _logger.default.error(`Encountered an error uploading snapshot: ${name}`, meta);
+          this._scheduleUpload(snap.name, { ...snap,
+            resources
+          });
+        });
+      } catch (error) {
+        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);
+          this.log.error(error, snapshot.meta);
+        }
+      }
+    }.bind(this));
+  } // Queues a snapshot upload with the provided options
 
-        _logger.default.error(error);
-      }));
-    }).catch(error => {
-      _logger.default.error(`Encountered an error taking snapshot: ${name}`, meta);
 
-      _logger.default.error(error);
-    });
-  }
+  _scheduleUpload(name, options) {
+    var _this$build4;
 
-  capture({
-    url,
-    name,
-    waitFor,
-    execute,
-    snapshots = [],
-    ...options
-  }) {
-    (0, _assert.default)(this.isRunning(), 'Not running');
-    (0, _assert.default)(url, `Missing URL for${name ? ` ${name}` : ' snapshots'}`);
-    snapshots = name ? [{
-      name,
-      execute
-    }].concat(snapshots) : snapshots;
-    (0, _assert.default)(snapshots.length && snapshots.every(s => s.name), `Missing name for ${url}`); // the entire capture process happens within the async capture queue
-
-    return _classPrivateFieldGet(this, _captures).push(async () => {
-      let results = [];
-      let page;
+    if ((_this$build4 = this.build) !== null && _this$build4 !== void 0 && _this$build4.error) {
+      throw new Error(this.build.error);
+    }
 
+    return this.#uploads.push(`upload/${name}`, async () => {
       try {
-        // borrow a page from the discoverer
-        page = await this.discoverer.page(); // allow @percy/dom injection
-
-        await page.setBypassCSP(true); // set any request headers
-
-        await page.setExtraHTTPHeaders(options.requestHeaders || {}); // @todo - resize viewport
-        // go to and wait for network idle
-
-        await page.goto(url, {
-          waitUntil: 'networkidle2'
-        }); // inject @percy/dom for serialization
-
-        await page.addScriptTag({
-          path: require.resolve('@percy/dom')
-        }); // wait for any other elements or timeout before snapshotting
-
-        if (waitFor) await page.waitFor(waitFor); // multiple snapshots can be captured on a single page
-
-        for (let {
-          name,
-          execute
-        } of snapshots) {
-          // optionally execute a script to interact with the page
-          if (execute) await execute(page); // serialize and capture a DOM snapshot
-
-          /* istanbul ignore next: no instrumenting injected code */
-
-          let domSnapshot = await page.evaluate(({
-            enableJavaScript
-          }) =>
-          /* eslint-disable-next-line no-undef */
-          PercyDOM.serialize({
-            enableJavaScript
-          }), options); // snapshots are awaited on concurrently after sequentially capturing their DOM
-
-          results.push(this.snapshot({ ...options,
-            url,
-            name,
-            domSnapshot
-          }));
-        }
+        /* 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) {
-        _logger.default.error(`Encountered an error for page: ${url}`);
+        var _error$response;
 
-        _logger.default.error(error);
-      } finally {
-        var _page;
+        let failed = ((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.statusCode) === 422 && error.response.body.errors.find(e => {
+          var _e$source;
 
-        // await on any resulting snapshots
-        await Promise.all(results);
-        await ((_page = page) === null || _page === void 0 ? void 0 : _page.close());
+          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}`, options.meta);
+        this.log.error((failed === null || failed === void 0 ? void 0 : failed.detail) ?? error, options.meta); // build failed at some point, stop accepting snapshots
+
+        if (failed) {
+          this.build.error = failed.detail;
+          this.build.failed = true;
+          this.close();
+        }
       }
     });
   }
 
 }
-
-exports.default = Percy;
+export default Percy;