rx-queue - npm Package Compare versions

Comparing version 0.0.5 to 0.0.7

bundles/rx-queue.es6.umd.js

@@ -1,11 +0,11 @@
-/* rx-queue version 0.0.5 */
+/* rx-queue version 0.0.7 */
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Subject'), require('brolog')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Subject', 'brolog'], factory) :
-	(factory((global.window = {}),global.Subject,global.Brolog));
-}(this, (function (exports,Subject,Brolog) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Observable'), require('rxjs/Subject'), require('rxjs/add/operator/debounce'), require('rxjs/add/observable/interval'), require('brolog'), require('rxjs/add/observable/of'), require('rxjs/add/observable/empty'), require('rxjs/add/operator/concatMap'), require('rxjs/add/operator/concat'), require('rxjs/add/operator/delay'), require('rxjs/add/operator/throttle')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Observable', 'rxjs/Subject', 'rxjs/add/operator/debounce', 'rxjs/add/observable/interval', 'brolog', 'rxjs/add/observable/of', 'rxjs/add/observable/empty', 'rxjs/add/operator/concatMap', 'rxjs/add/operator/concat', 'rxjs/add/operator/delay', 'rxjs/add/operator/throttle'], factory) :
+	(factory((global.window = {}),global.Observable,global.Subject,null,null,global.Brolog));
+}(this, (function (exports,Observable,Subject,debounce,interval,Brolog) { 'use strict';
 
 Brolog = Brolog && Brolog.hasOwnProperty('default') ? Brolog['default'] : Brolog;
 
-const version = "0.0.5";
+const version = "0.0.7";
 
@@ -51,4 +51,104 @@ const log = new Brolog();
 
+class DebounceQueue extends RxQueue {
+    constructor(period) {
+        super(period);
+        log.verbose('DebounceQueue', 'constructor()');
+        this.subject = new Subject.Subject();
+        this.subscription = this.subject
+            .debounce(() => Observable.Observable.interval(this.period))
+            .subscribe((item) => super.next(item));
+    }
+    next(item) {
+        log.verbose('DebounceQueue', 'next()');
+        this.subject.next(item);
+    }
+    unsubscribe() {
+        this.subscription.unsubscribe();
+        super.unsubscribe();
+    }
+}
+
+class DelayQueue extends RxQueue {
+    constructor(period) {
+        super(period);
+        log.verbose('DelayQueue', 'constructor()');
+        this.subject = new Subject.Subject();
+        this.subscription = this.subject
+            .concatMap(args => {
+            return Observable.Observable.of(args) // emit first item right away
+                .concat(Observable.Observable.empty().delay(this.period)); // delay next item
+        })
+            .subscribe((item) => super.next(item));
+    }
+    next(item) {
+        log.verbose('DelayQueue', 'next()');
+        this.subject.next(item);
+    }
+    unsubscribe() {
+        this.subscription.unsubscribe();
+        super.unsubscribe();
+    }
+}
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class DelayQueueExector extends DelayQueue {
+    constructor(period) {
+        super(period);
+        log.verbose('DelayQueueExector', 'constructor()');
+        this.subscribe(unit => {
+            try {
+                const ret = unit.fn();
+                return unit.resolve(ret);
+            }
+            catch (e) {
+                return unit.reject(e);
+            }
+        });
+    }
+    execute(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            log.verbose('DelayQueueExector', 'execute()');
+            return new Promise((resolve, reject) => {
+                const unit = {
+                    fn,
+                    resolve,
+                    reject,
+                };
+                this.next(unit);
+            });
+        });
+    }
+}
+
+class ThrottleQueue extends RxQueue {
+    constructor(period) {
+        super(period);
+        log.verbose('ThrottleQueue', 'constructor()');
+        this.subject = new Subject.Subject();
+        this.subscription = this.subject
+            .throttle(_ => Observable.Observable.interval(this.period))
+            .subscribe((item) => super.next(item));
+    }
+    next(item) {
+        log.verbose('ThrottleQueue', 'next()');
+        this.subject.next(item);
+    }
+    unsubscribe() {
+        this.subscription.unsubscribe();
+        super.unsubscribe();
+    }
+}
+
+exports.DebounceQueue = DebounceQueue;
+exports.DelayQueue = DelayQueue;
+exports.DelayQueueExector = DelayQueueExector;
 exports.RxQueue = RxQueue;
-exports['default'] = RxQueue;
+exports.ThrottleQueue = ThrottleQueue;
 
@@ -55,0 +155,0 @@ Object.defineProperty(exports, '__esModule', { value: true });

bundles/rx-queue.umd.js

@@ -11,11 +11,38 @@ var __extends = (this && this.__extends) || (function () {
 })();
-/* rx-queue version 0.0.5 */
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/* rx-queue version 0.0.7 */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Subject'), require('brolog')) :
-        typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Subject', 'brolog'], factory) :
-            (factory((global.window = {}), global.Subject, global.Brolog));
-}(this, (function (exports, Subject, Brolog) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/Observable'), require('rxjs/Subject'), require('rxjs/add/operator/debounce'), require('rxjs/add/observable/interval'), require('brolog'), require('rxjs/add/observable/of'), require('rxjs/add/observable/empty'), require('rxjs/add/operator/concatMap'), require('rxjs/add/operator/concat'), require('rxjs/add/operator/delay'), require('rxjs/add/operator/throttle')) :
+        typeof define === 'function' && define.amd ? define(['exports', 'rxjs/Observable', 'rxjs/Subject', 'rxjs/add/operator/debounce', 'rxjs/add/observable/interval', 'brolog', 'rxjs/add/observable/of', 'rxjs/add/observable/empty', 'rxjs/add/operator/concatMap', 'rxjs/add/operator/concat', 'rxjs/add/operator/delay', 'rxjs/add/operator/throttle'], factory) :
+            (factory((global.window = {}), global.Observable, global.Subject, null, null, global.Brolog));
+}(this, (function (exports, Observable, Subject, debounce, interval, Brolog) {
     'use strict';
     Brolog = Brolog && Brolog.hasOwnProperty('default') ? Brolog['default'] : Brolog;
-    var version = "0.0.5";
+    var version = "0.0.7";
     var log = new Brolog();
@@ -63,4 +90,125 @@ var VERSION = version;
     }(Subject.Subject));
+    var DebounceQueue = /** @class */ (function (_super) {
+        __extends(DebounceQueue, _super);
+        function DebounceQueue(period) {
+            var _this = _super.call(this, period) || this;
+            log.verbose('DebounceQueue', 'constructor()');
+            _this.subject = new Subject.Subject();
+            _this.subscription = _this.subject
+                .debounce(function () { return Observable.Observable.interval(_this.period); })
+                .subscribe(function (item) { return _super.prototype.next.call(_this, item); });
+            return _this;
+        }
+        DebounceQueue.prototype.next = function (item) {
+            log.verbose('DebounceQueue', 'next()');
+            this.subject.next(item);
+        };
+        DebounceQueue.prototype.unsubscribe = function () {
+            this.subscription.unsubscribe();
+            _super.prototype.unsubscribe.call(this);
+        };
+        return DebounceQueue;
+    }(RxQueue));
+    var DelayQueue = /** @class */ (function (_super) {
+        __extends(DelayQueue, _super);
+        function DelayQueue(period) {
+            var _this = _super.call(this, period) || this;
+            log.verbose('DelayQueue', 'constructor()');
+            _this.subject = new Subject.Subject();
+            _this.subscription = _this.subject
+                .concatMap(function (args) {
+                return Observable.Observable.of(args) // emit first item right away
+                    .concat(Observable.Observable.empty().delay(_this.period)); // delay next item
+            })
+                .subscribe(function (item) { return _super.prototype.next.call(_this, item); });
+            return _this;
+        }
+        DelayQueue.prototype.next = function (item) {
+            log.verbose('DelayQueue', 'next()');
+            this.subject.next(item);
+        };
+        DelayQueue.prototype.unsubscribe = function () {
+            this.subscription.unsubscribe();
+            _super.prototype.unsubscribe.call(this);
+        };
+        return DelayQueue;
+    }(RxQueue));
+    var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+    var DelayQueueExector = /** @class */ (function (_super) {
+        __extends(DelayQueueExector, _super);
+        function DelayQueueExector(period) {
+            var _this = _super.call(this, period) || this;
+            log.verbose('DelayQueueExector', 'constructor()');
+            _this.subscribe(function (unit) {
+                try {
+                    var ret = unit.fn();
+                    return unit.resolve(ret);
+                }
+                catch (e) {
+                    return unit.reject(e);
+                }
+            });
+            return _this;
+        }
+        DelayQueueExector.prototype.execute = function (fn) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    log.verbose('DelayQueueExector', 'execute()');
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            var unit = {
+                                fn: fn,
+                                resolve: resolve,
+                                reject: reject,
+                            };
+                            _this.next(unit);
+                        })];
+                });
+            });
+        };
+        return DelayQueueExector;
+    }(DelayQueue));
+    var ThrottleQueue = /** @class */ (function (_super) {
+        __extends(ThrottleQueue, _super);
+        function ThrottleQueue(period) {
+            var _this = _super.call(this, period) || this;
+            log.verbose('ThrottleQueue', 'constructor()');
+            _this.subject = new Subject.Subject();
+            _this.subscription = _this.subject
+                .throttle(function (_) { return Observable.Observable.interval(_this.period); })
+                .subscribe(function (item) { return _super.prototype.next.call(_this, item); });
+            return _this;
+        }
+        ThrottleQueue.prototype.next = function (item) {
+            log.verbose('ThrottleQueue', 'next()');
+            this.subject.next(item);
+        };
+        ThrottleQueue.prototype.unsubscribe = function () {
+            this.subscription.unsubscribe();
+            _super.prototype.unsubscribe.call(this);
+        };
+        return ThrottleQueue;
+    }(RxQueue));
+    exports.DebounceQueue = DebounceQueue;
+    exports.DelayQueue = DelayQueue;
+    exports.DelayQueueExector = DelayQueueExector;
     exports.RxQueue = RxQueue;
-    exports['default'] = RxQueue;
+    exports.ThrottleQueue = ThrottleQueue;
     Object.defineProperty(exports, '__esModule', { value: true });
@@ -67,0 +215,0 @@ })));

package.json

 {
   "name": "rx-queue",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Easy to Use Queue based on RxJS for Delay/Throttle/Debounce Edit",
@@ -17,3 +17,3 @@ "main": "bundles/rx-queue.umd.js",
     "test:unit": "blue-tape -r ts-node/register -r source-map-support/register \"src/**/*.spec.ts\" \"tests/**/*.spec.ts\"",
-    "test:npm": "npm run dist && export TMPDIR=/tmp/npm.package.$$ && npm pack && mkdir $TMPDIR && mv *-*.*.*.tgz $TMPDIR && cp tests/fixtures/smoke-testing.js $TMPDIR && cd $TMPDIR && npm init -y && npm i *-*.*.*.tgz && node smoke-testing.js"
+    "test:npm": "npm run dist && export TMPDIR=/tmp/npm.package.$$ && npm pack && mkdir $TMPDIR && mv *-*.*.*.tgz $TMPDIR && cp tests/fixtures/smoke-testing.js $TMPDIR && cd $TMPDIR && npm init -y && npm i *-*.*.*.tgz rxjs brolog && node smoke-testing.js"
   },
@@ -40,3 +40,3 @@ "repository": {
   "homepage": "https://github.com/zixia/rx-queue#readme",
-  "dependencies": {
+  "peerDependencies": {
     "brolog": "^1.2",
@@ -50,4 +50,6 @@ "rxjs": "^5.5"
     "blue-tape": "^1.0.0",
+    "brolog": "^1.2",
     "rollup": "^0.50.0",
     "rollup-plugin-json": "^2.3.0",
+    "rxjs": "^5.5",
     "shx": "^0.2.2",
@@ -54,0 +56,0 @@ "sinon": "^4.0.1",

No alert changes

Improved metrics

Total package byte prevSize

92761

increased by29.04%

Number of package files

55

increased by7.84%

Lines of code

1265

increased by26.25%

Worsened metrics

Dev dependency count

15

increased by15.38%

Dependency changes

• - Removedbrolog@^1.2

• - Removedrxjs@^5.5