@percy/core 1.1.4 → 1.2.0

package/dist/browser.js

@@ -41,52 +41,49 @@ export class Browser extends EventEmitter {
   '--use-mock-keychain', // enable remote debugging on the first available port
   '--remote-debugging-port=0'];
 
-  constructor({
-    executable = process.env.PERCY_BROWSER_EXECUTABLE,
-    timeout = 30000,
-    headless = true,
-    cookies = [],
-    args = []
-  }) {
-    super();
-    this.launchTimeout = timeout;
-    this.executable = executable;
-    this.headless = headless;
-    /* istanbul ignore next: only false for debugging */
-
-    if (this.headless) this.args.push('--headless', '--hide-scrollbars', '--mute-audio');
-
-    for (let a of args) if (!this.args.includes(a)) this.args.push(a); // transform cookies object to an array of cookie params
-
-
-    this.cookies = Array.isArray(cookies) ? cookies : Object.entries(cookies).map(([name, value]) => ({
-      name,
-      value
-    }));
+  constructor(percy) {
+    super().percy = percy;
   }
 
   async launch() {
     // already launching or launched
     if (this.readyState != null) return;
-    this.readyState = 0; // check if any provided executable exists
+    this.readyState = 0;
+    let {
+      cookies = [],
+      launchOptions = {}
+    } = this.percy.config.discovery;
+    let {
+      executable,
+      headless = true,
+      args = [],
+      timeout
+    } = launchOptions; // transform cookies object to an array of cookie params
 
-    if (this.executable && !fs.existsSync(this.executable)) {
-      this.log.error(`Browser executable not found: ${this.executable}`);
-      this.executable = null;
+    this.cookies = Array.isArray(cookies) ? cookies : Object.entries(cookies).map(([name, value]) => ({
+      name,
+      value
+    })); // check if any provided executable exists
+
+    if (executable && !fs.existsSync(executable)) {
+      this.log.error(`Browser executable not found: ${executable}`);
+      executable = null;
     } // download and install the browser if not already present
 
 
-    this.executable || (this.executable = await install.chromium()); // create a temporary profile directory
+    this.executable = executable || (await install.chromium());
+    this.log.debug('Launching browser'); // create a temporary profile directory and collect additional launch arguments
 
-    this.profile = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'percy-browser-')); // spawn the browser process detached in its own group and session
+    this.profile = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'percy-browser-'));
+    /* istanbul ignore next: only false for debugging */
 
-    let args = this.args.concat(`--user-data-dir=${this.profile}`);
-    this.log.debug('Launching browser');
-    this.process = spawn(this.executable, args, {
-      detached: process.platform !== 'win32'
-    }); // connect a websocket to the devtools address
+    if (headless) this.args.push('--headless', '--hide-scrollbars', '--mute-audio');
 
-    this.ws = new WebSocket(await this.address(), {
+    for (let a of args) if (!this.args.includes(a)) this.args.push(a);
+
+    this.args.push(`--user-data-dir=${this.profile}`); // spawn the browser process and connect a websocket to the devtools address
+
+    this.ws = new WebSocket(await this.spawn(timeout), {
       perMessageDeflate: false
     }); // wait until the websocket has connected
 
@@ -214,13 +211,15 @@ export class Browser extends EventEmitter {
         });
       });
     }
-  } // Returns the devtools websocket address. If not already known, will watch the browser's
-  // stderr and resolves when it emits the devtools protocol address or rejects if the process
-  // exits for any reason or if the address does not appear after the timeout.
+  }
 
+  async spawn(timeout = 30000) {
+    // spawn the browser process detached in its own group and session
+    this.process = spawn(this.executable, this.args, {
+      detached: process.platform !== 'win32'
+    }); // watch the process stderr and resolve when it emits the devtools protocol address
 
-  async address(timeout = this.launchTimeout) {
-    this._address || (this._address = await new Promise((resolve, reject) => {
+    this.address = await new Promise((resolve, reject) => {
       let stderr = '';
 
       let handleData = chunk => {
@@ -247,8 +246,8 @@ export class Browser extends EventEmitter {
       this.process.stderr.on('close', handleExitClose);
       this.process.on('exit', handleExitClose);
       this.process.on('error', handleError);
-    }));
-    return this._address;
+    });
+    return this.address;
   }
 
   _handleMessage(data) {

package/dist/page.js

@@ -1,14 +1,15 @@
 import fs from 'fs';
 import logger from '@percy/logger';
 import Network from './network.js';
-import { hostname, generatePromise, waitFor } from './utils.js';
 import { PERCY_DOM } from './api.js';
+import { hostname, waitFor, waitForTimeout as sleep, serializeFunction } from './utils.js';
 export class Page {
   static TIMEOUT = 30000;
   log = logger('core:page');
 
   constructor(session, options) {
     this.session = session;
+    this.browser = session.browser;
     this.enableJavaScript = options.enableJavaScript ?? true;
     this.network = new Network(this, options);
     this.meta = options.meta;
@@ -79,10 +80,7 @@ export class Page {
     try {
       // trigger navigation and poll for handlers to have finished
       await Promise.all([navigate(), waitFor(() => {
-        if (this.session.closedReason) {
-          throw new Error(this.session.closedReason);
-        }
-
+        if (this.session.closedReason) throw new Error(this.session.closedReason);
         return handlers.every(handler => handler.finished);
       }, Page.TIMEOUT)]);
     } catch (error) {
@@ -99,38 +97,11 @@ export class Page {
 
 
   async eval(fn, ...args) {
-    let fnbody = fn.toString(); // we might have a function shorthand if this fails
-
-    /* eslint-disable-next-line no-new, no-new-func */
-
-    try {
-      new Function(`(${fnbody})`);
-    } catch (error) {
-      fnbody = fnbody.startsWith('async ') ? fnbody.replace(/^async/, 'async function') : `function ${fnbody}`;
-      /* eslint-disable-next-line no-new, no-new-func */
-
-      try {
-        new Function(`(${fnbody})`);
-      } catch (error) {
-        throw new Error('The provided function is not serializable');
-      }
-    } // wrap the function body with percy helpers
-
-
-    fnbody = 'function withPercyHelpers() {\n' + [`return (${fnbody})({ generatePromise, waitFor }, ...arguments);`, `${generatePromise}`, `${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,
       exceptionDetails
     } = await this.session.send('Runtime.callFunctionOn', {
-      functionDeclaration: fnbody,
+      functionDeclaration: serializeFunction(fn),
       arguments: args.map(value => ({
         value
       })),
@@ -151,19 +122,12 @@ export class Page {
   async evaluate(scripts) {
     var _scripts;
 
-    scripts && (scripts = [].concat(scripts));
-    if (!((_scripts = scripts) !== null && _scripts !== void 0 && _scripts.length)) return;
+    if (!((_scripts = scripts && (scripts = [].concat(scripts))) !== null && _scripts !== void 0 && _scripts.length)) return;
     this.log.debug('Evaluate JavaScript', { ...this.meta,
       scripts
     });
 
-    for (let script of scripts) {
-      if (typeof script === 'string') {
-        script = `async eval() {\n${script}\n}`;
-      }
-
-      await this.eval(script);
-    }
+    for (let script of scripts) await this.eval(script);
   } // Take a snapshot after waiting for any timeout, waiting for any selector, executing any scripts,
   // and waiting for the network idle
 
@@ -173,29 +137,28 @@ export class Page {
     waitForTimeout,
     waitForSelector,
     execute,
+    meta,
     ...options
   }) {
     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));
+      await sleep(waitForTimeout);
     } // wait for any specified selector
 
 
     if (waitForSelector) {
       this.log.debug(`Wait for selector: ${waitForSelector}`, this.meta);
-      /* istanbul ignore next: no instrumenting injected code */
-
-      await this.eval(function waitForSelector({
-        waitFor
-      }, selector, timeout) {
-        return waitFor(() => !!document.querySelector(selector), timeout).catch(() => Promise.reject(new Error(`Failed to find "${selector}"`)));
-      }, waitForSelector, Page.TIMEOUT);
+      await this.eval(`await waitForSelector(${JSON.stringify(waitForSelector)}, ${Page.TIMEOUT})`);
     } // execute any javascript
 
 
-    await this.evaluate(typeof execute === 'object' && !Array.isArray(execute) ? execute.beforeSnapshot : execute); // wait for any final network activity before capturing the dom snapshot
+    if (execute) {
+      let execBefore = typeof execute === 'object' && !Array.isArray(execute);
+      await this.evaluate(execBefore ? 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
@@ -248,7 +211,11 @@ export class Page {
 
   _handleExecutionContextCreated = event => {
     if (this.session.targetId === event.context.auxData.frameId) {
-      this.contextId = event.context.id;
+      this.contextId = event.context.id; // inject global percy config as soon as possible
+
+      this.eval(`window.__PERCY__ = ${JSON.stringify({
+        config: this.browser.percy.config
+      })};`).catch(this.session._handleClosedError);
     }
   };
   _handleExecutionContextDestroyed = event => {

package/dist/percy.js

@@ -67,20 +67,14 @@ export class Percy {
       clientInfo,
       environmentInfo
     });
-    this.browser = new Browser({ ...this.config.discovery.launchOptions,
-      cookies: this.config.discovery.cookies
-    });
-
-    if (server) {
-      this.server = createPercyServer(this, port);
-    } // generator methods are wrapped to autorun and return promises
-
+    if (server) this.server = createPercyServer(this, port);
+    this.browser = new Browser(this); // generator methods are wrapped to autorun and return promises
 
     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[m] = (...args) => generatePromise(method(...args)).then();
+      this[m] = (...args) => generatePromise(method(...args));
     }
   } // Shortcut for controlling the global logger's log level.
 
@@ -205,9 +199,9 @@ export class Percy {
       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
+      this.readyState = 3; // when uploads are deferred, cancel build creation on abort
 
-      if (error.canceled && this.deferUploads) {
+      if (this.deferUploads && error.name === 'AbortError') {
         this.#uploads.cancel('build/create');
         this.readyState = null;
       } // throw an easier-to-understand error when the port is taken
@@ -249,10 +243,10 @@ export class Percy {
         }
       }
     } catch (error) {
-      // reopen closed queues when canceled
+      // reopen closed queues when aborted
 
       /* istanbul ignore else: all errors bubble */
-      if (close && error.canceled) {
+      if (close && error.name === 'AbortError') {
         this.#snapshots.open();
         this.#uploads.open();
       }
@@ -285,10 +279,10 @@ export class Percy {
       // process uploads and close queues
       yield* this.yield.flush(true);
     } catch (error) {
-      // reset ready state when canceled
+      // reset ready state when aborted
 
       /* istanbul ignore else: all errors bubble */
-      if (error.canceled) this.readyState = 1;
+      if (error.name === 'AbortError') this.readyState = 1;
       throw error;
     } // if dry-running, log the total number of snapshots
 
@@ -437,8 +431,8 @@ export class Percy {
           });
         });
       } catch (error) {
-        if (error.canceled) {
-          this.log.error('Received a duplicate snapshot name, ' + `the previous snapshot was canceled: ${snapshot.name}`);
+        if (error.name === 'AbortError') {
+          this.log.error('Received a duplicate snapshot name, ' + `the previous snapshot was aborted: ${snapshot.name}`, snapshot.meta);
         } else {
           this.log.error(`Encountered an error taking snapshot: ${snapshot.name}`, snapshot.meta);
           this.log.error(error, snapshot.meta);

package/dist/queue.js

@@ -1,4 +1,4 @@
-import { generatePromise, waitFor } from './utils.js';
+import { yieldFor, generatePromise, AbortController } from './utils.js';
 export class Queue {
   running = true;
   closed = false;
@@ -9,13 +9,13 @@ export class Queue {
     this.concurrency = concurrency;
   }
 
-  push(id, callback, priority) {
+  push(id, generator, priority) {
     /* istanbul ignore next: race condition paranoia */
     if (this.closed && !id.startsWith('@@/')) return;
     this.cancel(id);
     let task = {
       id,
-      callback,
+      generator,
       priority
     };
     task.promise = new Promise((resolve, reject) => {
@@ -31,9 +31,9 @@ export class Queue {
   }
 
   cancel(id) {
-    var _this$pending$get, _this$pending$get$can;
+    var _this$pending$get, _this$pending$get$ctr;
 
-    (_this$pending$get = this.#pending.get(id)) === null || _this$pending$get === void 0 ? void 0 : (_this$pending$get$can = _this$pending$get.cancel) === null || _this$pending$get$can === void 0 ? void 0 : _this$pending$get$can.call(_this$pending$get);
+    (_this$pending$get = this.#pending.get(id)) === null || _this$pending$get === void 0 ? void 0 : (_this$pending$get$ctr = _this$pending$get.ctrl) === null || _this$pending$get$ctr === void 0 ? void 0 : _this$pending$get$ctr.abort();
     this.#pending.delete(id);
     this.#queued.delete(id);
   }
@@ -76,7 +76,7 @@ export class Queue {
   }
 
   idle(callback) {
-    return waitFor(() => {
+    return yieldFor(() => {
       callback === null || callback === void 0 ? void 0 : callback(this.#pending.size);
       return !this.#pending.size;
     }, {
@@ -85,7 +85,7 @@ export class Queue {
   }
 
   empty(callback) {
-    return waitFor(() => {
+    return yieldFor(() => {
       callback === null || callback === void 0 ? void 0 : callback(this.size);
       return !this.size;
     }, {
@@ -93,19 +93,23 @@ export class Queue {
     });
   }
 
-  flush(callback) {
+  async *flush(callback) {
     let stopped = !this.running;
     this.run().push('@@/flush', () => {
       if (stopped) this.stop();
     });
-    return this.idle(pend => {
-      let left = [...this.#queued.keys()].indexOf('@@/flush');
-      if (!~left && !this.#pending.has('@@/flush')) left = 0;
-      callback === null || callback === void 0 ? void 0 : callback(pend + left);
-    }).canceled(() => {
+
+    try {
+      yield* this.idle(pend => {
+        let left = [...this.#queued.keys()].indexOf('@@/flush');
+        if (!~left && !this.#pending.has('@@/flush')) left = 0;
+        callback === null || callback === void 0 ? void 0 : callback(pend + left);
+      });
+    } catch (error) {
       if (stopped) this.stop();
       this.cancel('@@/flush');
-    });
+      throw error;
+    }
   }
 
   next() {
@@ -126,26 +130,12 @@ export class Queue {
     if (!task) return;
     this.#queued.delete(task.id);
     this.#pending.set(task.id, task);
-
-    let done = callback => arg => {
-      var _task$cancel;
-
-      if (!((_task$cancel = task.cancel) !== null && _task$cancel !== void 0 && _task$cancel.triggered)) {
-        this.#pending.delete(task.id);
-      }
-
-      callback(arg);
-
-      this._dequeue();
-    };
-
-    try {
-      let gen = generatePromise(task.callback);
-      task.cancel = gen.cancel;
-      return gen.then(done(task.resolve), done(task.reject));
-    } catch (err) {
-      done(task.reject)(err);
-    }
+    let ctrl = task.ctrl = new AbortController();
+    return generatePromise(task.generator, ctrl.signal, (err, val) => {
+      if (!ctrl.signal.aborted) this.#pending.delete(task.id);
+      task[err ? 'reject' : 'resolve'](err ?? val);
+      return this._dequeue();
+    });
   }
 
 }

package/dist/session.js

@@ -95,7 +95,7 @@ export class Session extends EventEmitter {
   /* istanbul ignore next: encountered during closing races */
 
   _handleClosedError = error => {
-    if (!error.message.endsWith(this.closedReason)) {
+    if (!(error.message ?? error).endsWith(this.closedReason)) {
       this.log.debug(error, this.meta);
     }
   };

package/dist/snapshot.js

@@ -31,14 +31,12 @@ export function snapshotMatches(snapshot, include, exclude) {
   let test = (predicate, fallback) => {
     if (predicate && typeof predicate === 'string') {
       // snapshot name matches exactly or matches a glob
-      let result = snapshot.name === predicate || micromatch.isMatch(snapshot.name, predicate, {
-        basename: !predicate.startsWith('/')
-      }); // snapshot might match a string-based regexp pattern
+      let result = snapshot.name === predicate || micromatch.isMatch(snapshot.name, predicate); // snapshot might match a string-based regexp pattern
 
       if (!result) {
         try {
-          let [, parsed = predicate, flags] = RE_REGEXP.exec(predicate) || [];
-          result = new RegExp(parsed, flags).test(snapshot.name);
+          let [, parsed, flags] = RE_REGEXP.exec(predicate) || [];
+          result = !!parsed && new RegExp(parsed, flags).test(snapshot.name);
         } catch {}
       }
 
@@ -203,12 +201,12 @@ export function getSnapshotConfig(percy, options) {
       userAgent: percy.config.discovery.userAgent
     }
   }, options], (path, prev, next) => {
-    var _next;
+    var _next, _next2;
 
     switch (path.map(k => k.toString()).join('.')) {
       case 'widths':
         // dedup, sort, and override widths when not empty
-        return [path, (_next = next) !== null && _next !== void 0 && _next.length ? Array.from(new Set(next)).sort((a, b) => a - b) : prev];
+        return [path, !((_next = next) !== null && _next !== void 0 && _next.length) ? prev : Array.from(new Set(next)).sort((a, b) => a - b)];
 
       case 'percyCSS':
         // concatenate percy css
@@ -220,7 +218,7 @@ export function getSnapshotConfig(percy, options) {
 
       case 'discovery.disallowedHostnames':
         // prevent disallowing the root hostname
-        return [path, (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
+        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
     } // ensure additional snapshots have complete names
 
 
@@ -357,8 +355,6 @@ export async function* discoverSnapshotResources(percy, snapshot, callback) {
   });
 
   try {
-    var _snapshot$execute;
-
     // set the initial page size
     yield page.resize({
       width: widths.shift(),
@@ -366,18 +362,26 @@ export async function* discoverSnapshotResources(percy, snapshot, callback) {
     }); // 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
+
+    if (snapshot.execute) {
+      // when any execute options are provided, inject snapshot options
+
+      /* istanbul ignore next: cannot detect coverage of injected code */
+      yield page.eval((_, s) => window.__PERCY__.snapshot = s, snapshot);
+      yield page.evaluate(snapshot.execute.afterNavigation);
+    } // trigger resize events for other widths
+
 
     for (let width of widths) {
-      var _snapshot$execute2, _snapshot$execute3;
+      var _snapshot$execute, _snapshot$execute2;
 
-      yield page.evaluate((_snapshot$execute2 = snapshot.execute) === null || _snapshot$execute2 === void 0 ? void 0 : _snapshot$execute2.beforeResize);
+      yield page.evaluate((_snapshot$execute = snapshot.execute) === null || _snapshot$execute === void 0 ? void 0 : _snapshot$execute.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);
+      yield page.evaluate((_snapshot$execute2 = snapshot.execute) === null || _snapshot$execute2 === void 0 ? void 0 : _snapshot$execute2.afterResize);
     }
 
     if (snapshot.domSnapshot) {

package/dist/utils.js

@@ -1,3 +1,4 @@
+import EventEmitter from 'events';
 import { sha256hash } from '@percy/client/utils';
 export { request, getPackageJSON, hostnameMatches } from '@percy/client/utils'; // Returns the hostname portion of a URL.
 
@@ -44,84 +45,171 @@ export function createPercyCSSResource(url, css) {
 
 export function createLogResource(logs) {
   return createResource(`/percy.${Date.now()}.log`, JSON.stringify(logs), 'text/plain');
-} // Creates a thennable, cancelable, generator instance
+} // Iterates over the provided generator and resolves to the final value when done. With an
+// AbortSignal, the generator will throw with the abort reason when aborted. Also accepts an
+// optional node-style callback, called before the returned promise resolves.
 
-export function generatePromise(gen) {
-  var _gen, _gen2;
+export async function generatePromise(gen, signal, cb) {
+  try {
+    var _gen;
 
-  // 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 {
-    name = 'Canceled';
-    canceled = true;
-  } // recursively runs the generator, maybe throwing an error when canceled
-
-
-  let handleNext = async (g, last) => {
-    let canceled = g.cancel.triggered;
+    if (typeof signal === 'function') [cb, signal] = [signal];
+    if (typeof gen === 'function') gen = await gen();
     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
+    } = typeof ((_gen = gen) === null || _gen === void 0 ? void 0 : _gen.next) === 'function' && (typeof gen[Symbol.iterator] === 'function' || typeof gen[Symbol.asyncIterator] === 'function') ? await gen.next() : {
+      done: true,
+      value: await gen
+    };
+
+    while (!done) {
+      var _signal;
+
+      ({
+        done,
+        value
+      } = (_signal = signal) !== null && _signal !== void 0 && _signal.aborted ? await gen.throw(signal.reason) : await gen.next(value));
+    }
+
+    if (!cb) return value;
+    return cb(null, value);
+  } catch (error) {
+    if (!cb) throw error;
+    return cb(error);
+  }
+} // Bare minimum AbortController polyfill for Node < 16.14
+
+export class AbortController {
+  signal = new EventEmitter();
+
+  abort(reason = new AbortError()) {
+    if (this.signal.aborted) return;
+    Object.assign(this.signal, {
+      reason,
+      aborted: true
+    });
+    this.signal.emit('abort', reason);
+  }
+
+} // Similar to DOMException[AbortError] but accepts additional properties
+
+export class AbortError extends Error {
+  constructor(msg = 'This operation was aborted', props) {
+    Object.assign(super(msg), {
+      name: 'AbortError',
+      ...props
+    });
+  }
+
+} // An async generator that infinitely yields to the predicate function until a truthy value is
+// returned. When a timeout is provided, an error will be thrown during the next iteration after the
+// timeout has been exceeded. If an idle option is provided, the predicate will be yielded to a
+// second time, after the idle period, to ensure the yielded value is still truthy. The poll option
+// determines how long to wait before yielding to the predicate function during each iteration.
+
+export async function* yieldFor(predicate, options = {}) {
+  if (Number.isInteger(options)) options = {
+    timeout: options
+  };
+  let {
+    timeout,
+    idle,
+    poll = 10
+  } = options;
+  let start = Date.now();
+  let done, value;
+
+  while (true) {
+    if (timeout && Date.now() - start >= timeout) {
+      throw new Error(`Timeout of ${timeout}ms exceeded.`);
+    } else if (!(value = yield predicate())) {
+      done = await waitForTimeout(poll, false);
+    } else if (idle && !done) {
+      done = await waitForTimeout(idle, true);
+    } else {
+      return value;
+    }
+  }
+} // Promisified version of `yieldFor` above.
+
+export function waitFor() {
+  return generatePromise(yieldFor(...arguments));
+} // Promisified version of `setTimeout` (no callback argument).
+
+export function waitForTimeout() {
+  return new Promise(resolve => setTimeout(resolve, ...arguments));
+} // Browser-specific util to wait for a query selector to exist within an optional timeout.
+
+/* istanbul ignore next: tested, but coverage is stripped */
+
+async function waitForSelector(selector, timeout) {
+  try {
+    return await waitFor(() => document.querySelector(selector), timeout);
+  } catch {
+    throw new Error(`Unable to find: ${selector}`);
+  }
+} // Browser-specific util to wait for an xpath selector to exist within an optional timeout.
+
+/* istanbul ignore next: tested, but coverage is stripped */
+
+
+async function waitForXPath(selector, timeout) {
+  try {
+    let xpath = () => document.evaluate(selector, document, null, 9, null);
+
+    return await waitFor(() => xpath().singleNodeValue, timeout);
+  } catch {
+    throw new Error(`Unable to find: ${selector}`);
+  }
+} // Browser-specific util to scroll to the bottom of a page, optionally calling the provided function
+// after each window segment has been scrolled.
 
+/* istanbul ignore next: tested, but coverage is stripped */
+
+
+async function scrollToBottom(options, onScroll) {
+  if (typeof options === 'function') [onScroll, options] = [options];
+
+  let size = () => Math.ceil(document.body.scrollHeight / window.innerHeight);
+
+  for (let s, i = 1; i < (s = size()); i++) {
+    var _onScroll;
+
+    window.scrollTo({ ...options,
+      top: window.innerHeight * i
+    });
+    await ((_onScroll = onScroll) === null || _onScroll === void 0 ? void 0 : _onScroll(i, s));
+  }
+} // Serializes the provided function with percy helpers for use in evaluating browser scripts
+
+
+export function serializeFunction(fn) {
+  let fnbody = typeof fn === 'string' ? `async eval() {\n${fn}\n}` : fn.toString(); // we might have a function shorthand if this fails
+
+  /* eslint-disable-next-line no-new, no-new-func */
+
+  try {
+    new Function(`(${fnbody})`);
+  } catch (error) {
+    fnbody = fnbody.startsWith('async ') ? fnbody.replace(/^async/, 'async function') : `function ${fnbody}`;
+    /* eslint-disable-next-line no-new, no-new-func */
 
-  let cancelable = async function* () {
     try {
-      return yield* gen;
+      new Function(`(${fnbody})`);
     } catch (error) {
-      if (error.canceled) {
-        let cancelers = cancelable.cancelers || [];
+      throw new Error('The provided function is not serializable');
+    }
+  } // wrap the function body with percy helpers
 
-        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.
+  fnbody = 'function withPercyHelpers() {\n' + ['const { config, snapshot } = window.__PERCY__ ?? {};', `return (${fnbody})({`, '  config, snapshot, generatePromise, yieldFor,', '  waitFor, waitForTimeout, waitForSelector, waitForXPath,', '  scrollToBottom', '}, ...arguments);', `${generatePromise}`, `${yieldFor}`, `${waitFor}`, `${waitForTimeout}`, `${waitForSelector}`, `${waitForXPath}`, `${scrollToBottom}`].join('\n') + '\n}';
+  /* istanbul ignore else: ironic. */
 
-export function waitFor(predicate, options) {
-  let {
-    poll = 10,
-    timeout,
-    idle
-  } = 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()));
+  if (fnbody.includes('cov_')) {
+    // remove coverage statements during testing
+    fnbody = fnbody.replace(/cov_.*?(;\n?|,)\s*/g, '');
+  }
+
+  return fnbody;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -39,10 +39,10 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.1.4",
-    "@percy/config": "1.1.4",
-    "@percy/dom": "1.1.4",
-    "@percy/logger": "1.1.4",
+    "@percy/client": "1.2.0",
+    "@percy/config": "1.2.0",
+    "@percy/dom": "1.2.0",
+    "@percy/logger": "1.2.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -53,5 +53,5 @@
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "gitHead": "ca09298265b043703b94dd5c37dd9f2489312049"
+  "gitHead": "ab7652e08dab49b3efbe2968339c5a70391ed4ff"
 }