@percy/core 1.0.0-beta.69 → 1.0.0-beta.72

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,13 +21,15 @@ var _server = _interopRequireDefault(require("./server"));
 
 var _snapshot = require("./snapshot");
 
+var _utils2 = require("./utils");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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 _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
-function _classApplyDescriptorSet(receiver, descriptor, value) { 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; } }
+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); }
 
@@ -39,8 +41,6 @@ var _uploads = /*#__PURE__*/new WeakMap();
 
 var _snapshots = /*#__PURE__*/new WeakMap();
 
-var _total = /*#__PURE__*/new WeakMap();
-
 // 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
@@ -73,40 +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()
     });
 
-    _total.set(this, {
-      writable: true,
-      value: 0
-    });
+    _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,
@@ -158,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);
 
@@ -183,122 +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 at the end
-
-
-    if (this.dryRun && _classPrivateFieldGet(this, _total)) {
-      this.log.info(`Found ${_classPrivateFieldGet(this, _total)} snapshot${_classPrivateFieldGet(this, _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);
@@ -319,39 +360,46 @@ class Percy {
     } // get derived snapshot config options
 
 
-    let snapshot = (0, _snapshot.getSnapshotConfig)(this, options); // clear any existing pending upload for the same snapshot (for retries)
-
-    _classPrivateFieldGet(this, _uploads).clear(`upload/${snapshot.name}`); // resolves after asset discovery has finished and the upload has been queued
-
-
-    return _classPrivateFieldGet(this, _snapshots).push(`snapshot/${snapshot.name}`, async () => {
-      var _snapshot$additionalS, _snapshot$additionalS2;
+    let snapshot = (0, _snapshot.getSnapshotConfig)(this, options); // clear any existing snapshot uploads of the same name (for retries)
 
-      _classPrivateFieldSet(this, _total, _classPrivateFieldGet(this, _total) + (((_snapshot$additionalS = (_snapshot$additionalS2 = snapshot.additionalSnapshots) === null || _snapshot$additionalS2 === void 0 ? void 0 : _snapshot$additionalS2.length) !== null && _snapshot$additionalS !== void 0 ? _snapshot$additionalS : 0) + 1));
+    for (let {
+      name
+    } of [snapshot, ...(snapshot.additionalSnapshots || [])]) {
+      _classPrivateFieldGet(this, _uploads).cancel(`upload/${name}`);
+    } // resolves after asset discovery has finished and uploads have been queued
 
-      (0, _snapshot.debugSnapshotConfig)(snapshot, this.dryRun);
-      if (this.dryRun) return;
 
+    return _classPrivateFieldGet(this, _snapshots).push(`snapshot/${snapshot.name}`, async function* () {
       try {
-        await (0, _snapshot.discoverSnapshotResources)(this, snapshot, (snapshot, resources) => {
-          this.log.info(`Snapshot taken: ${snapshot.name}`, snapshot.meta);
+        yield* (0, _snapshot.discoverSnapshotResources)(this, snapshot, (snap, resources) => {
+          if (!this.dryRun) this.log.info(`Snapshot taken: ${snap.name}`, snap.meta);
 
-          this._scheduleUpload(snapshot, resources);
+          this._scheduleUpload(snap.name, { ...snap,
+            resources
+          });
         });
       } catch (error) {
-        this.log.error(`Encountered an error taking snapshot: ${snapshot.name}`, snapshot.meta);
-        this.log.error(error, snapshot.meta);
-      }
-    });
-  } // Queues a snapshot upload with the provided configuration options and resources
+        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);
+        }
+      } // fixes an issue in Node 12 where implicit returns do not correctly resolve the async
+      // generator objects — https://crbug.com/v8/10238
 
 
-  _scheduleUpload(snapshot, resources) {
-    _classPrivateFieldGet(this, _uploads).push(`upload/${snapshot.name}`, async () => {
+      return; // eslint-disable-line no-useless-return
+    }.bind(this));
+  } // Queues a snapshot upload with the provided options
+
+
+  _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;
 
@@ -360,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;
@@ -373,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); }
@@ -25,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()
     });
@@ -39,7 +43,11 @@ 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,
       callback,
@@ -51,8 +59,6 @@ class Queue {
         reject
       });
 
-      _classPrivateFieldGet(this, _queued).delete(id);
-
       _classPrivateFieldGet(this, _queued).set(id, task);
 
       this._dequeue();
@@ -60,12 +66,22 @@ class Queue {
     return task.promise;
   }
 
-  clear(id) {
-    if (id != null) {
-      _classPrivateFieldGet(this, _queued).delete(id);
-    } else {
-      _classPrivateFieldGet(this, _queued).clear();
-    }
+  cancel(id) {
+    var _classPrivateFieldGet2, _classPrivateFieldGet3;
+
+    (_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();
 
     return this.size;
   }
@@ -87,30 +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)(() => !_classPrivateFieldGet(this, _pending).size, {
+  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() {
@@ -134,8 +168,12 @@ class Queue {
 
     _classPrivateFieldGet(this, _pending).set(task.id, task);
 
-    let done = (callback, arg) => {
-      _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);
 
@@ -143,12 +181,16 @@ class Queue {
     };
 
     try {
-      return Promise.resolve(task.callback()).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;