@firestitch/common 12.4.2 → 12.5.1

package/bundles/firestitch-common.umd.js

@@ -1502,25 +1502,42 @@
         function Queue(_limit) {
             if (_limit === void 0) { _limit = Infinity; }
             this._limit = _limit;
+            this._queueStats = {
+                completed: 0,
+                total: 0,
+                errors: [],
+            };
+            this._doneQueueStats = {
+                completed: 0,
+                total: 0,
+                errors: [],
+            };
+            this._completeQueueStats = {
+                completed: 0,
+                total: 0,
+                errors: [],
+            };
             this._done = new rxjs.Subject();
             this._queue = [];
             this._inProgress = [];
-            this._total = 0;
-            this._completed = 0;
-            this._errors = 0;
             this._state = exports.QueueState.Idle;
             this._destroy$ = new rxjs.Subject();
+            // if(_targets) {
+            //   _targets.forEach((target) => {
+            //     this.push(target);
+            //   }); 
+            // }
         }
         Object.defineProperty(Queue.prototype, "total", {
             get: function () {
-                return this._total;
+                return this._queueStats.total;
             },
             enumerable: false,
             configurable: true
         });
         Object.defineProperty(Queue.prototype, "completed", {
             get: function () {
-                return this._completed;
+                return this._queueStats.completed;
             },
             enumerable: false,
             configurable: true
@@ -1541,7 +1558,7 @@
         });
         Object.defineProperty(Queue.prototype, "errors", {
             get: function () {
-                return this._errors;
+                return this._queueStats.errors;
             },
             enumerable: false,
             configurable: true
@@ -1585,31 +1602,41 @@
         Queue.prototype.setLimit = function (value) {
             this._limit = value;
         };
+        /**
+         * @depreated
+         */
         Queue.prototype.subscribe = function (fun, err, complete) {
-            this._done
-                .pipe(operators.takeUntil(this._destroy$))
+            this.observe$
                 .subscribe(fun, err, complete);
         };
-        Queue.prototype.complete = function (fun, err, complete) {
-            var _this = this;
-            rxjs.Observable.create(function (observer) {
-                if (!_this.isProcessing()) {
-                    observer.next();
-                    observer.complete();
-                    return;
+        Object.defineProperty(Queue.prototype, "observe$", {
+            get: function () {
+                return this._done
+                    .pipe(operators.takeUntil(this._destroy$));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Queue.prototype, "complete$", {
+            get: function () {
+                var _this = this;
+                if (!this.isProcessing()) {
+                    return rxjs.of({ total: 0, completed: 0, errors: [] });
                 }
-                _this.subscribe(function () {
-                    observer.next();
-                    observer.complete();
-                }, function (error) {
-                    observer.error(error);
-                    _this.clear();
-                });
-            }).subscribe(fun, err, complete);
+                return this.observe$
+                    .pipe(operators.take(1), operators.map(function () { return (_this._completeQueueStats); }));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Queue.prototype.complete = function (fun, err, complete) {
+            this.complete$.subscribe(fun, err, complete);
         };
         Queue.prototype.push = function (target, name) {
             var operation = new Operation(target, name);
-            this._total++;
+            this._queueStats.total++;
+            this._doneQueueStats.total++;
+            this._completeQueueStats.total++;
             this._state = exports.QueueState.Processing;
             if (this._inProgress.length < this._limit) {
                 this._processOperation(operation);
@@ -1621,53 +1648,62 @@
         };
         Queue.prototype.clear = function () {
             this._queue = [];
-            this._total = 0;
-            this._errors = 0;
-            this._completed = 0;
             this._state = exports.QueueState.Idle;
-            this._done = new rxjs.Subject();
+            this._queueStats = {
+                total: 0,
+                errors: [],
+                completed: 0,
+            };
+            this._clearDoneQueueStats();
         };
         Queue.prototype.destroy = function () {
-            this.clear();
             this._done.complete();
+            this.clear();
         };
         Queue.prototype._processOperation = function (operation) {
             var _this = this;
             this._inProgress.push(operation);
             operation.target
                 .pipe(operators.delay(200), // Hack to prevent extra quick proccess execution
-            operators.takeUntil(this._destroy$)).subscribe({
+            operators.finalize(function () {
+                var opIndex = _this._inProgress.indexOf(operation);
+                _this._inProgress.splice(opIndex, 1);
+                if (_this.empty) {
+                    _this._state = exports.QueueState.Idle;
+                    _this._done.next(_this._doneQueueStats);
+                    _this._clearDoneQueueStats();
+                }
+                else {
+                    if (_this._queue.length) {
+                        var queueItem = _this._queue.shift();
+                        _this._processOperation(queueItem);
+                    }
+                }
+            }), operators.takeUntil(this._destroy$)).subscribe({
                 next: function (data) {
                     operation.ready$.next(data);
                 },
                 error: function (error) {
-                    var opIndex = _this._inProgress.indexOf(operation);
-                    _this._inProgress.splice(opIndex, 1);
-                    _this._errors++;
+                    _this._queueStats.errors.push(error);
+                    _this._doneQueueStats.errors.push(error);
+                    _this._completeQueueStats.errors.push(error);
                     operation.ready$.error(error);
-                    if (_this.empty) {
-                        _this._state = exports.QueueState.Idle;
-                        _this._done.error(error);
-                    }
                 },
                 complete: function () {
-                    var opIndex = _this._inProgress.indexOf(operation);
-                    _this._inProgress.splice(opIndex, 1);
-                    _this._completed++;
+                    _this._queueStats.completed++;
+                    _this._doneQueueStats.completed++;
+                    _this._completeQueueStats.completed++;
                     operation.ready$.complete();
-                    if (_this.empty) {
-                        _this._state = exports.QueueState.Idle;
-                        _this._done.next();
-                    }
-                    else {
-                        if (_this._queue.length) {
-                            var queueItem = _this._queue.shift();
-                            _this._processOperation(queueItem);
-                        }
-                    }
                 }
             });
         };
+        Queue.prototype._clearDoneQueueStats = function () {
+            this._doneQueueStats = {
+                total: 0,
+                errors: [],
+                completed: 0,
+            };
+        };
         return Queue;
     }());