@percy/core 1.6.3 → 1.7.1

package/dist/percy.js

@@ -5,7 +5,7 @@ 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
+import { generatePromise, yieldAll } 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.
@@ -69,10 +69,6 @@ export class Percy {
       this.#snapshots.concurrency = concurrency;
     }
 
-    if (this.delayUploads) {
-      this.#uploads.concurrency = 1;
-    }
-
     this.client = new PercyClient({
       token,
       clientInfo,
@@ -162,17 +158,20 @@ export class Percy {
     let buildTask = this.#uploads.push('build/create', () => {
       // pause other queued tasks until after the build is created
       this.#uploads.stop();
+      this.build = {};
       return this.client.createBuild().then(({
         data: {
           id,
           attributes
         }
       }) => {
-        this.build = {
-          id
-        };
-        this.build.number = attributes['build-number'];
-        this.build.url = attributes['web-url'];
+        let url = attributes['web-url'];
+        let number = attributes['build-number'];
+        Object.assign(this.build, {
+          id,
+          url,
+          number
+        });
         if (!this.delayUploads) this.#uploads.run();
       });
     }, 0); // handle deferred build errors
@@ -246,6 +245,7 @@ export class Percy {
         if (close) this.#uploads.close(); // prevent creating an empty build when deferred
 
         if (!this.deferUploads || !this.#uploads.has('build/create') || this.#uploads.size > 1) {
+          if (this.build && !this.build.id) yield* this.#uploads.idle();
           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;
@@ -371,7 +371,7 @@ export class Percy {
     } 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)));
+      return yieldAll(options.map(o => this.yield.snapshot(o)));
     }
 
     if (typeof options === 'string') {
@@ -398,13 +398,11 @@ export class Percy {
         } // gather snapshots from options
 
 
-        let snapshots = yield gatherSnapshots(this, options);
+        let snapshots = yield* gatherSnapshots(this, options);
 
         try {
-          // yield each task individually to allow canceling
-          let tasks = snapshots.map(s => this._takeSnapshot(s));
-
-          for (let task of tasks) yield task;
+          // use a try-catch to cancel snapshots that haven't started when the error occurred
+          yield* yieldAll(snapshots.map(s => this._takeSnapshot(s)));
         } catch (error) {
           // cancel queued snapshots that may not have started
           snapshots.map(s => this._cancelSnapshot(s));
@@ -458,10 +456,10 @@ export class Percy {
 
     if ((_this$build4 = this.build) !== null && _this$build4 !== void 0 && _this$build4.error) throw new Error(this.build.error); // maybe process any existing delayed uploads
 
-    if (!this.skipUploads && this.delayUploads) this.#uploads.run();
+    if (!this.skipUploads && this.delayUploads && (!this.build || this.build.id)) this.#uploads.run();
     return this.#uploads.push(`upload/${name}`, async () => {
       // when delayed, stop the queue before other uploads are processed
-      if (this.delayUploads) this.#uploads.stop();
+      if (this.readyState < 2 && this.delayUploads) this.#uploads.stop();
 
       try {
         /* istanbul ignore if: useful for other internal packages */

package/dist/snapshot.js

@@ -2,7 +2,7 @@ import logger from '@percy/logger';
 import PercyConfig from '@percy/config';
 import micromatch from 'micromatch';
 import { configSchema } from './config.js';
-import { request, hostnameMatches, createRootResource, createPercyCSSResource, createLogResource } from './utils.js'; // Throw a better error message for missing or invalid urls
+import { request, hostnameMatches, createRootResource, createPercyCSSResource, createLogResource, yieldTo } from './utils.js'; // Throw a better error message for missing or invalid urls
 
 export function validURL(url, base) {
   if (!url) {
@@ -92,21 +92,20 @@ export function mapSnapshotOptions(percy, snapshots, config) {
   }, []);
 } // Returns an array of derived snapshot options
 
-export async function gatherSnapshots(percy, options) {
+export async function* gatherSnapshots(percy, options) {
   let {
     baseUrl,
     snapshots
   } = options;
   if ('url' in options) snapshots = [options];
-  if ('sitemap' in options) snapshots = await getSitemapSnapshots(options); // validate evaluated snapshots
+  if ('sitemap' in options) snapshots = yield getSitemapSnapshots(options); // validate evaluated snapshots
 
   if (typeof snapshots === 'function') {
-    ({
-      snapshots
-    } = validateSnapshotOptions({
+    snapshots = yield* yieldTo(snapshots(baseUrl));
+    snapshots = validateSnapshotOptions({
       baseUrl,
-      snapshots: await snapshots(baseUrl)
-    }));
+      snapshots
+    }).snapshots;
   } // map snapshots with snapshot options
 
 

package/dist/utils.js

@@ -46,23 +46,25 @@ export function createPercyCSSResource(url, css) {
 
 export function createLogResource(logs) {
   return createResource(`/percy.${Date.now()}.log`, JSON.stringify(logs), 'text/plain');
+} // Returns true or false if the provided object is a generator or not
+
+export function isGenerator(subject) {
+  return typeof (subject === null || subject === void 0 ? void 0 : subject.next) === 'function' && (typeof subject[Symbol.iterator] === 'function' || typeof subject[Symbol.asyncIterator] === 'function');
 } // 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 async function generatePromise(gen, signal, cb) {
   try {
-    var _gen;
-
     if (typeof signal === 'function') [cb, signal] = [signal];
     if (typeof gen === 'function') gen = await gen();
     let {
       done,
       value
-    } = 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() : {
+    } = !isGenerator(gen) ? {
       done: true,
       value: await gen
-    };
+    } : await gen.next();
 
     while (!done) {
       var _signal;
@@ -103,6 +105,33 @@ export class AbortError extends Error {
     });
   }
 
+} // An async generator that yields after every event loop until the promise settles
+
+export async function* yieldTo(subject) {
+  var _subject;
+
+  let pending = typeof ((_subject = subject) === null || _subject === void 0 ? void 0 : _subject.finally) === 'function';
+  if (pending) subject = subject.finally(() => pending = false);
+  /* eslint-disable-next-line no-unmodified-loop-condition */
+
+  while (pending) yield new Promise(r => setImmediate(r));
+
+  return isGenerator(subject) ? yield* subject : await subject;
+} // An async generator that runs provided generators concurrently
+
+export async function* yieldAll(all) {
+  let res = new Array(all.length).fill();
+  all = all.map(yieldTo);
+
+  while (true) {
+    res = await Promise.all(all.map((g, i) => {
+      var _res$i, _res$i2;
+
+      return (_res$i = res[i]) !== null && _res$i !== void 0 && _res$i.done ? res[i] : g.next((_res$i2 = res[i]) === null || _res$i2 === void 0 ? void 0 : _res$i2.value);
+    }));
+    let vals = res.map(r => r === null || r === void 0 ? void 0 : r.value);
+    if (res.some(r => !(r !== null && r !== void 0 && r.done))) yield vals;else return vals;
+  }
 } // 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
@@ -182,11 +211,14 @@ async function scrollToBottom(options, onScroll) {
     });
     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
+} // Used to test if a string looks like a function
+
 
+const FUNC_REG = /^(async\s+)?(function\s*)?(\w+\s*)?\(.*?\)\s*(\{|=>)/is; // 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
+  // stringify or convert a function body into a complete function
+  let fnbody = typeof fn === 'string' && !FUNC_REG.test(fn) ? `async function eval() {\n${fn}\n}` : fn.toString(); // we might have a function shorthand if this fails
 
   /* eslint-disable-next-line no-new, no-new-func */
 
@@ -204,7 +236,7 @@ export function serializeFunction(fn) {
   } // wrap the function body with percy helpers
 
 
-  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}';
+  fnbody = 'function withPercyHelpers() {\n' + ['const { config, snapshot } = window.__PERCY__ ?? {};', `return (${fnbody})({`, '  config, snapshot, generatePromise, yieldFor,', '  waitFor, waitForTimeout, waitForSelector, waitForXPath,', '  scrollToBottom', '}, ...arguments);', `${isGenerator}`, `${generatePromise}`, `${yieldFor}`, `${waitFor}`, `${waitForTimeout}`, `${waitForSelector}`, `${waitForXPath}`, `${scrollToBottom}`].join('\n') + '\n}';
   /* istanbul ignore else: ironic. */
 
   if (fnbody.includes('cov_')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.6.3",
+  "version": "1.7.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -39,10 +39,10 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.6.3",
-    "@percy/config": "1.6.3",
-    "@percy/dom": "1.6.3",
-    "@percy/logger": "1.6.3",
+    "@percy/client": "1.7.1",
+    "@percy/config": "1.7.1",
+    "@percy/dom": "1.7.1",
+    "@percy/logger": "1.7.1",
     "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": "ab48a150317a4af36d536a5671701532c669d2d1"
+  "gitHead": "012892cdaf7a07aa1b5aa355017639cee0e8a19e"
 }