flinker 1.0.0 → 1.0.6

package/dist/esm/RXOperator.js

@@ -0,0 +1,481 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { RXEmitter, RXJustComplete } from './RXPublisher.js';
+import { RXSubscriber } from './RXSubscriber.js';
+var RXOperator = /** @class */ (function () {
+    function RXOperator(pipeline) {
+        this.type = 'operator';
+        //--------------------------------------
+        //  isComplete
+        //--------------------------------------
+        this._isComplete = false;
+        this.pipeline = pipeline;
+    }
+    Object.defineProperty(RXOperator.prototype, "isComplete", {
+        get: function () { return this._isComplete; },
+        enumerable: false,
+        configurable: true
+    });
+    //--------------------------------------
+    //  RXSender Protocol
+    //--------------------------------------
+    RXOperator.prototype.send = function (value, broadcast) {
+        var _a;
+        if (!this.isComplete) {
+            (_a = this.child) === null || _a === void 0 ? void 0 : _a.send(value, broadcast);
+        }
+    };
+    RXOperator.prototype.sendError = function (e, broadcast) {
+        var _a;
+        if (!this.isComplete) {
+            (_a = this.child) === null || _a === void 0 ? void 0 : _a.sendError(e, broadcast);
+        }
+    };
+    RXOperator.prototype.sendComplete = function (broadcast) {
+        var _a;
+        if (!this.isComplete) {
+            this._isComplete = true;
+            (_a = this.child) === null || _a === void 0 ? void 0 : _a.sendComplete(broadcast);
+        }
+    };
+    //--------------------------------------
+    //  OPERATORS
+    //--------------------------------------
+    RXOperator.prototype.skipFirst = function () {
+        return this.addChild(new RXSkipFirst(this.pipeline));
+    };
+    RXOperator.prototype.skipNullable = function () {
+        return this.addChild(new RXSkipNullable(this.pipeline));
+    };
+    RXOperator.prototype.removeDuplicates = function (value) {
+        return this.addChild(new RXRemoveDuplicates(this.pipeline, value));
+    };
+    RXOperator.prototype.debounce = function (ms) {
+        return this.addChild(new RXDebounce(this.pipeline, ms));
+    };
+    RXOperator.prototype.map = function (f) {
+        return this.addChild(new RXMap(this.pipeline, f));
+    };
+    RXOperator.prototype.flatMap = function (f) {
+        return this.addChild(new RXFlatMap(this.pipeline, f));
+    };
+    RXOperator.prototype.forEach = function (f) {
+        return this.addChild(new RXForEach(this.pipeline, f));
+    };
+    RXOperator.prototype.sequent = function (f) {
+        return this.addChild(new RXSequent(this.pipeline, f));
+    };
+    RXOperator.prototype.parallel = function (f) {
+        return this.addChild(new RXParallel(this.pipeline, f));
+    };
+    RXOperator.prototype.filter = function (predicate) {
+        return this.addChild(new RXFilter(this.pipeline, predicate));
+    };
+    RXOperator.prototype.spread = function () {
+        return this.addChild(new RXSpread(this.pipeline));
+    };
+    RXOperator.prototype.replaceError = function (replaceWith) {
+        return this.addChild(new RXReplaceError(this.pipeline, replaceWith));
+    };
+    RXOperator.prototype.addChild = function (op) {
+        this.child = op;
+        return op;
+    };
+    //--------------------------------------
+    //  Output
+    //--------------------------------------
+    RXOperator.prototype.fork = function () {
+        var subscriber = new RXSubscriber(this.pipeline);
+        this.child = subscriber;
+        var dispatcher = new RXEmitter();
+        subscriber.onReceive(function (v) { dispatcher.send(v); });
+        subscriber.onError(function (e) { dispatcher.sendError(e); });
+        subscriber.onComplete(function () { dispatcher.sendComplete(); });
+        subscriber.subscribe();
+        return dispatcher.asObservable;
+    };
+    RXOperator.prototype.onReceive = function (f) {
+        var subscriber = new RXSubscriber(this.pipeline);
+        this.child = subscriber;
+        return subscriber.onReceive(f);
+    };
+    RXOperator.prototype.onError = function (f) {
+        var subscriber = new RXSubscriber(this.pipeline);
+        this.child = subscriber;
+        return subscriber.onError(f);
+    };
+    RXOperator.prototype.onComplete = function (f) {
+        var subscriber = new RXSubscriber(this.pipeline);
+        this.child = subscriber;
+        return subscriber.onComplete(f);
+    };
+    return RXOperator;
+}());
+export { RXOperator };
+//--------------------------------------
+//  RXMap
+//--------------------------------------
+var RXMap = /** @class */ (function (_super) {
+    __extends(RXMap, _super);
+    function RXMap(pipe, mapper) {
+        var _this = _super.call(this, pipe) || this;
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXMap.prototype.send = function (value, broadcast) {
+        var newValue = this.mapper(value);
+        _super.prototype.send.call(this, newValue, broadcast);
+    };
+    return RXMap;
+}(RXOperator));
+export { RXMap };
+//--------------------------------------
+//  RXFlatMap
+//--------------------------------------
+var RXFlatMap = /** @class */ (function (_super) {
+    __extends(RXFlatMap, _super);
+    function RXFlatMap(pipe, mapper) {
+        var _this = _super.call(this, pipe) || this;
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXFlatMap.prototype.send = function (value, broadcast) {
+        var _this = this;
+        if (this.isComplete)
+            return;
+        this.mapper(value).pipe()
+            .onReceive(function (v) {
+            _super.prototype.send.call(_this, v, broadcast);
+        })
+            .onError(function (e) {
+            _this.sendError(e, broadcast);
+        })
+            .subscribe();
+    };
+    return RXFlatMap;
+}(RXOperator));
+export { RXFlatMap };
+var RXForEach = /** @class */ (function (_super) {
+    __extends(RXForEach, _super);
+    function RXForEach(pipe, mapper) {
+        var _this = _super.call(this, pipe) || this;
+        _this.buffer = Array();
+        _this.willComplete = false;
+        _this.willCompleteBroadcast = false;
+        _this.curOp = new RXJustComplete();
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXForEach.prototype.send = function (value, broadcast) {
+        this.buffer.push({ hasError: false, value: value, broadcast: broadcast });
+        this.processNext();
+    };
+    RXForEach.prototype.sendError = function (error, broadcast) {
+        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+        this.processNext();
+    };
+    RXForEach.prototype.sendComplete = function (broadcast) {
+        this.willComplete = true;
+        this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
+        this.processNext();
+    };
+    RXForEach.prototype.processNext = function () {
+        var _this = this;
+        if (!this.curOp.isComplete)
+            return;
+        var notification = this.buffer.shift();
+        if (notification) {
+            if (notification.hasError) {
+                _super.prototype.sendError.call(this, notification.error, notification.broadcast);
+                this.processNext();
+            }
+            else if (notification.value !== undefined) {
+                this.curOp = this.mapper(notification.value);
+                this.curOp.pipe()
+                    .onReceive(function (v) {
+                    _super.prototype.send.call(_this, v, notification.broadcast);
+                })
+                    .onError(function (e) {
+                    _super.prototype.sendError.call(_this, e, notification.broadcast);
+                })
+                    .onComplete(function () { _this.processNext(); })
+                    .subscribe();
+            }
+            else {
+                this.processNext();
+            }
+        }
+        else {
+            if (this.willComplete)
+                _super.prototype.sendComplete.call(this, this.willCompleteBroadcast);
+        }
+    };
+    return RXForEach;
+}(RXOperator));
+export { RXForEach };
+var RXSequent = /** @class */ (function (_super) {
+    __extends(RXSequent, _super);
+    function RXSequent(pipe, mapper) {
+        var _this = _super.call(this, pipe) || this;
+        _this.buffer = Array();
+        _this.willComplete = false;
+        _this.willCompleteBroadcast = false;
+        _this.curOp = new RXJustComplete();
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXSequent.prototype.send = function (value, broadcast) {
+        this.buffer.push({ hasError: false, value: value, broadcast: broadcast });
+        this.processNext();
+    };
+    RXSequent.prototype.sendError = function (error, broadcast) {
+        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+        this.processNext();
+    };
+    RXSequent.prototype.sendComplete = function (broadcast) {
+        this.willComplete = true;
+        this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
+        this.processNext();
+    };
+    RXSequent.prototype.processNext = function () {
+        var _this = this;
+        if (!this.curOp.isComplete)
+            return;
+        var notification = this.buffer.shift();
+        if (notification) {
+            if (notification.hasError) {
+                _super.prototype.sendError.call(this, notification.error, notification.broadcast);
+                this.processNext();
+            }
+            else if (notification.value !== undefined) {
+                this.curOp = this.mapper(notification.value);
+                this.curOp.pipe()
+                    .onReceive(function (v) {
+                    _super.prototype.send.call(_this, v, notification.broadcast);
+                })
+                    .onError(function (e) {
+                    _super.prototype.sendError.call(_this, e, notification.broadcast);
+                })
+                    .onComplete(function () { _this.processNext(); })
+                    .subscribe();
+            }
+            else {
+                this.processNext();
+            }
+        }
+        else {
+            if (this.willComplete)
+                _super.prototype.sendComplete.call(this, this.willCompleteBroadcast);
+        }
+    };
+    return RXSequent;
+}(RXOperator));
+export { RXSequent };
+//--------------------------------------
+//  RXParallel
+//--------------------------------------
+var RXParallel = /** @class */ (function (_super) {
+    __extends(RXParallel, _super);
+    function RXParallel(pipe, mapper) {
+        var _this = _super.call(this, pipe) || this;
+        _this.willComplete = false;
+        _this.willCompleteBroadcast = false;
+        _this.activeOperations = 0;
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXParallel.prototype.send = function (value, broadcast) {
+        var _this = this;
+        this.activeOperations++;
+        this.mapper(value).pipe()
+            .onReceive(function (v) {
+            _super.prototype.send.call(_this, v, broadcast);
+        })
+            .onError(function (e) {
+            _super.prototype.sendError.call(_this, e, broadcast);
+        })
+            .onComplete(function () {
+            _this.activeOperations--;
+            if (_this.activeOperations === 0 && _this.willComplete)
+                _super.prototype.sendComplete.call(_this, _this.willCompleteBroadcast);
+        })
+            .subscribe();
+    };
+    RXParallel.prototype.sendComplete = function (broadcast) {
+        this.willComplete = true;
+        this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
+        if (this.activeOperations === 0) {
+            _super.prototype.sendComplete.call(this, broadcast);
+        }
+    };
+    return RXParallel;
+}(RXOperator));
+export { RXParallel };
+//--------------------------------------
+//  RXFilter
+//--------------------------------------
+var RXFilter = /** @class */ (function (_super) {
+    __extends(RXFilter, _super);
+    function RXFilter(pipe, predicate) {
+        var _this = _super.call(this, pipe) || this;
+        _this.predicate = predicate;
+        return _this;
+    }
+    RXFilter.prototype.send = function (value, broadcast) {
+        if (this.predicate(value))
+            _super.prototype.send.call(this, value, broadcast);
+    };
+    return RXFilter;
+}(RXOperator));
+export { RXFilter };
+//--------------------------------------
+//  RXSpread
+//--------------------------------------
+var RXSpread = /** @class */ (function (_super) {
+    __extends(RXSpread, _super);
+    function RXSpread() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RXSpread.prototype.send = function (value, broadcast) {
+        var _this = this;
+        if (Array.isArray(value)) {
+            value.forEach(function (v) {
+                _super.prototype.send.call(_this, v, broadcast);
+            });
+        }
+        else
+            _super.prototype.send.call(this, value, broadcast);
+    };
+    return RXSpread;
+}(RXOperator));
+export { RXSpread };
+//--------------------------------------
+//  RXSkipFirst
+//--------------------------------------
+//ignore value emitted just after registration of a new subscriber
+var RXSkipFirst = /** @class */ (function (_super) {
+    __extends(RXSkipFirst, _super);
+    function RXSkipFirst() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RXSkipFirst.prototype.send = function (value, broadcast) {
+        if (broadcast)
+            _super.prototype.send.call(this, value, broadcast);
+    };
+    return RXSkipFirst;
+}(RXOperator));
+export { RXSkipFirst };
+//--------------------------------------
+//  RXSkipNullable
+//--------------------------------------
+var RXSkipNullable = /** @class */ (function (_super) {
+    __extends(RXSkipNullable, _super);
+    function RXSkipNullable() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RXSkipNullable.prototype.send = function (value, broadcast) {
+        if (value !== null && value !== undefined)
+            _super.prototype.send.call(this, value, broadcast);
+    };
+    return RXSkipNullable;
+}(RXOperator));
+export { RXSkipNullable };
+//--------------------------------------
+//  RXRemoveDuplicates
+//--------------------------------------
+var RXRemoveDuplicates = /** @class */ (function (_super) {
+    __extends(RXRemoveDuplicates, _super);
+    function RXRemoveDuplicates(pipe, value) {
+        var _this = _super.call(this, pipe) || this;
+        _this.prevValue = undefined;
+        _this.prevValue = value;
+        return _this;
+    }
+    RXRemoveDuplicates.prototype.send = function (value, broadcast) {
+        if (this.prevValue !== value) {
+            this.prevValue = value;
+            _super.prototype.send.call(this, value, broadcast);
+        }
+    };
+    return RXRemoveDuplicates;
+}(RXOperator));
+export { RXRemoveDuplicates };
+var RXDebounce = /** @class */ (function (_super) {
+    __extends(RXDebounce, _super);
+    function RXDebounce(pipe, ms) {
+        var _this = _super.call(this, pipe) || this;
+        _this.buffer = Array();
+        _this.willComplete = false;
+        _this.willCompleteBroadcast = false;
+        _this.timeoutId = undefined;
+        _this.ms = ms;
+        return _this;
+    }
+    RXDebounce.prototype.startTimer = function () {
+        var _this = this;
+        if (this.timeoutId)
+            return;
+        this.timeoutId = setTimeout(function () {
+            _this.timeoutId = undefined;
+            for (var i = _this.buffer.length - 1; i >= 0; i--) {
+                var notification = _this.buffer[i];
+                if (notification.hasError) {
+                    _super.prototype.sendError.call(_this, notification.error, notification.broadcast);
+                }
+                else {
+                    _super.prototype.send.call(_this, notification.value, notification.broadcast);
+                }
+                //if (notification.broadcast) break
+                break;
+            }
+            _this.buffer.length = 0;
+            if (_this.willComplete)
+                _super.prototype.sendComplete.call(_this, _this.willCompleteBroadcast);
+        }, this.ms);
+    };
+    RXDebounce.prototype.send = function (value, broadcast) {
+        this.buffer.push({ hasError: false, value: value, broadcast: broadcast });
+        this.startTimer();
+    };
+    RXDebounce.prototype.sendError = function (error, broadcast) {
+        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+        this.startTimer();
+    };
+    RXDebounce.prototype.sendComplete = function (broadcast) {
+        this.willComplete = true;
+        this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
+        this.startTimer();
+    };
+    return RXDebounce;
+}(RXOperator));
+export { RXDebounce };
+//--------------------------------------
+//  RXReplaceError
+//--------------------------------------
+var RXReplaceError = /** @class */ (function (_super) {
+    __extends(RXReplaceError, _super);
+    function RXReplaceError(pipe, replaceWith) {
+        var _this = _super.call(this, pipe) || this;
+        _this.replaceWith = replaceWith;
+        return _this;
+    }
+    RXReplaceError.prototype.sendError = function (e, broadcast) {
+        var value = this.replaceWith(e);
+        value ? this.send(value, broadcast) : _super.prototype.sendError.call(this, e, broadcast);
+    };
+    return RXReplaceError;
+}(RXOperator));
+export { RXReplaceError };

package/dist/esm/RXPipeline.js

@@ -0,0 +1,24 @@
+import { RXOperator } from './RXOperator.js';
+var RXPipeline = /** @class */ (function () {
+    function RXPipeline(dispatcher) {
+        this.type = 'pipeline';
+        this.child = new RXOperator(this);
+        this.dispatcher = dispatcher;
+    }
+    Object.defineProperty(RXPipeline.prototype, "asOperator", {
+        get: function () { return this.child; },
+        enumerable: false,
+        configurable: true
+    });
+    RXPipeline.prototype.send = function (value, broadcast) {
+        this.child.send(value, broadcast);
+    };
+    RXPipeline.prototype.sendError = function (e, broadcast) {
+        this.child.sendError(e, broadcast);
+    };
+    RXPipeline.prototype.sendComplete = function (broadcast) {
+        this.child.sendComplete(broadcast);
+    };
+    return RXPipeline;
+}());
+export { RXPipeline };