@percy/core 1.0.0-beta.8 → 1.0.1

package/dist/queue.js

@@ -1,103 +1,152 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
+import { generatePromise, waitFor } from './utils.js';
+export class Queue {
+  running = true;
+  closed = false;
+  #queued = new Map();
+  #pending = new Map();
+
+  constructor(concurrency = 10) {
+    this.concurrency = concurrency;
+  }
 
-var _idle = _interopRequireDefault(require("./utils/idle"));
+  push(id, callback, priority) {
+    /* istanbul ignore next: race condition paranoia */
+    if (this.closed && !id.startsWith('@@/')) return;
+    this.cancel(id);
+    let task = {
+      id,
+      callback,
+      priority
+    };
+    task.promise = new Promise((resolve, reject) => {
+      Object.assign(task, {
+        resolve,
+        reject
+      });
+      this.#queued.set(id, task);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+      this._dequeue();
+    });
+    return task.promise;
+  }
 
-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; }
+  cancel(id) {
+    var _this$pending$get, _this$pending$get$can;
 
-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; }
+    (_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.delete(id);
+    this.#queued.delete(id);
+  }
 
-var _queue = new WeakMap();
+  has(id) {
+    return this.#queued.has(id) || this.#pending.has(id);
+  }
 
-var _pending = new WeakMap();
+  clear() {
+    this.#queued.clear();
+    return this.size;
+  }
 
-// Concurrent task-based queue for handling snapshots and asset discovery.
-class Queue {
-  // Defaults to inifinite concurrency
-  constructor(concurrency = Infinity) {
-    _queue.set(this, {
-      writable: true,
-      value: []
-    });
+  get size() {
+    return this.#queued.size + this.#pending.size;
+  }
 
-    _pending.set(this, {
-      writable: true,
-      value: 0
-    });
+  run() {
+    this.running = true;
 
-    this.concurrency = concurrency;
-  } // Pushing a new task to the queue will attempt to run it unless the
-  // concurrency limit has been reached. The returned promise will resolve or
-  // reject when the task has succeeded or thrown an error.
+    while (this.running && this.#queued.size && this.#pending.size < this.concurrency) this._dequeue();
 
+    return this;
+  }
 
-  push(task) {
-    return new Promise((resolve, reject) => {
-      _classPrivateFieldGet(this, _queue).push({
-        task,
-        resolve,
-        reject
-      });
+  stop() {
+    this.running = false;
+    return this;
+  }
 
-      this._dequeue();
-    });
-  } // Returns the amount of queued and pending tasks.
+  open() {
+    this.closed = false;
+    return this;
+  }
 
+  close(abort) {
+    if (abort) this.stop().clear();
+    this.closed = true;
+    return this;
+  }
 
-  get length() {
-    return _classPrivateFieldGet(this, _queue).length + _classPrivateFieldGet(this, _pending);
-  } // Resolves when there are no more queued or pending tasks.
+  idle(callback) {
+    return waitFor(() => {
+      callback === null || callback === void 0 ? void 0 : callback(this.#pending.size);
+      return !this.#pending.size;
+    }, {
+      idle: 10
+    });
+  }
 
+  empty(callback) {
+    return waitFor(() => {
+      callback === null || callback === void 0 ? void 0 : callback(this.size);
+      return !this.size;
+    }, {
+      idle: 10
+    });
+  }
 
-  idle() {
-    return (0, _idle.default)(() => this.length);
-  } // Clears the active queue. Tasks that were queued will not be executed and
-  // tasks that are pending (have already executed) will be allowed to finish.
+  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(() => {
+      if (stopped) this.stop();
+      this.cancel('@@/flush');
+    });
+  }
 
+  next() {
+    let next;
 
-  clear() {
-    _classPrivateFieldSet(this, _queue, []);
+    for (let [id, task] of this.#queued) {
+      if (!next || task.priority != null && next.priority == null || task.priority < next.priority) next = task;
+      if (id === '@@/flush') break;
+    }
 
-    return this.length;
-  } // Begins processing the queue by running the oldest task first. Pending tasks
-  // are tracked and no tasks will run unless there are less pending than the
-  // concurrency limit. More tasks are dequeued when the current task
-  // finishes. Resolves when the current task finishes although this method
-  // should never be awaited on so multiple tasks can run concurrently.
+    return next;
+  }
 
+  _dequeue() {
+    if (!this.running) return;
+    if (this.#pending.size >= this.concurrency) return;
+    let task = this.next();
+    if (!task) return;
+    this.#queued.delete(task.id);
+    this.#pending.set(task.id, task);
 
-  async _dequeue() {
-    var _this$pending;
+    let done = callback => arg => {
+      var _task$cancel;
 
-    if (_classPrivateFieldGet(this, _pending) >= this.concurrency) return;
+      if (!((_task$cancel = task.cancel) !== null && _task$cancel !== void 0 && _task$cancel.triggered)) {
+        this.#pending.delete(task.id);
+      }
 
-    let item = _classPrivateFieldGet(this, _queue).shift();
+      callback(arg);
 
-    if (!item) return;
-    _classPrivateFieldSet(this, _pending, (_this$pending = +_classPrivateFieldGet(this, _pending)) + 1), _this$pending;
+      this._dequeue();
+    };
 
     try {
-      var _this$pending2;
-
-      let value = await item.task();
-      _classPrivateFieldSet(this, _pending, (_this$pending2 = +_classPrivateFieldGet(this, _pending)) - 1), _this$pending2;
-      item.resolve(value);
-    } catch (error) {
-      var _this$pending3;
-
-      _classPrivateFieldSet(this, _pending, (_this$pending3 = +_classPrivateFieldGet(this, _pending)) - 1), _this$pending3;
-      item.reject(error);
-    } finally {
-      this._dequeue();
+      let gen = generatePromise(task.callback);
+      task.cancel = gen.cancel;
+      return gen.then(done(task.resolve), done(task.reject));
+    } catch (err) {
+      done(task.reject)(err);
     }
   }
 
 }
-
-exports.default = Queue;
+export default Queue;