flinker 1.0.7 → 2.0.1

package/dist/esm/RXOperator.js

@@ -1,22 +1,7 @@
-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) {
+import { RXEmitter, RXJustComplete } from './RXPublisher';
+import { RXSubscriber } from './RXSubscriber';
+export class RXOperator {
+    constructor(pipeline) {
         this.type = 'operator';
         //--------------------------------------
         //  isComplete
@@ -24,194 +9,173 @@ var RXOperator = /** @class */ (function () {
         this._isComplete = false;
         this.pipeline = pipeline;
     }
-    Object.defineProperty(RXOperator.prototype, "isComplete", {
-        get: function () { return this._isComplete; },
-        enumerable: false,
-        configurable: true
-    });
+    get isComplete() { return this._isComplete; }
     //--------------------------------------
     //  RXSender Protocol
     //--------------------------------------
-    RXOperator.prototype.send = function (value, broadcast) {
-        var _a;
+    send(value, broadcast) {
         if (!this.isComplete) {
-            (_a = this.child) === null || _a === void 0 ? void 0 : _a.send(value, broadcast);
+            this.child?.send(value, broadcast);
         }
-    };
-    RXOperator.prototype.sendError = function (e, broadcast) {
-        var _a;
+    }
+    sendError(e, broadcast) {
         if (!this.isComplete) {
-            (_a = this.child) === null || _a === void 0 ? void 0 : _a.sendError(e, broadcast);
+            this.child?.sendError(e, broadcast);
         }
-    };
-    RXOperator.prototype.sendComplete = function (broadcast) {
-        var _a;
+    }
+    sendComplete(broadcast) {
         if (!this.isComplete) {
             this._isComplete = true;
-            (_a = this.child) === null || _a === void 0 ? void 0 : _a.sendComplete(broadcast);
+            this.child?.sendComplete(broadcast);
         }
-    };
+    }
     //--------------------------------------
     //  OPERATORS
     //--------------------------------------
-    RXOperator.prototype.skipFirst = function () {
+    skipFirst() {
         return this.addChild(new RXSkipFirst(this.pipeline));
-    };
-    RXOperator.prototype.skipNullable = function () {
+    }
+    skipNullable() {
         return this.addChild(new RXSkipNullable(this.pipeline));
-    };
-    RXOperator.prototype.removeDuplicates = function (value) {
+    }
+    removeDuplicates(value) {
         return this.addChild(new RXRemoveDuplicates(this.pipeline, value));
-    };
-    RXOperator.prototype.debounce = function (ms) {
+    }
+    debounce(ms) {
         return this.addChild(new RXDebounce(this.pipeline, ms));
-    };
-    RXOperator.prototype.map = function (f) {
+    }
+    map(f) {
         return this.addChild(new RXMap(this.pipeline, f));
-    };
-    RXOperator.prototype.flatMap = function (f) {
+    }
+    flatMap(f) {
         return this.addChild(new RXFlatMap(this.pipeline, f));
-    };
-    RXOperator.prototype.forEach = function (f) {
+    }
+    forEach(f) {
         return this.addChild(new RXForEach(this.pipeline, f));
-    };
-    RXOperator.prototype.sequent = function (f) {
+    }
+    sequent(f) {
         return this.addChild(new RXSequent(this.pipeline, f));
-    };
-    RXOperator.prototype.parallel = function (f) {
+    }
+    parallel(f) {
         return this.addChild(new RXParallel(this.pipeline, f));
-    };
-    RXOperator.prototype.filter = function (predicate) {
+    }
+    filter(predicate) {
         return this.addChild(new RXFilter(this.pipeline, predicate));
-    };
-    RXOperator.prototype.spread = function () {
+    }
+    spread() {
         return this.addChild(new RXSpread(this.pipeline));
-    };
-    RXOperator.prototype.replaceError = function (replaceWith) {
+    }
+    replaceError(replaceWith) {
         return this.addChild(new RXReplaceError(this.pipeline, replaceWith));
-    };
-    RXOperator.prototype.addChild = function (op) {
+    }
+    addChild(op) {
         this.child = op;
         return op;
-    };
+    }
     //--------------------------------------
     //  Output
     //--------------------------------------
-    RXOperator.prototype.fork = function () {
-        var subscriber = new RXSubscriber(this.pipeline);
+    fork() {
+        const 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(); });
+        const dispatcher = new RXEmitter();
+        subscriber.onReceive((v) => { dispatcher.send(v); });
+        subscriber.onError((e) => { dispatcher.sendError(e); });
+        subscriber.onComplete(() => { dispatcher.sendComplete(); });
         subscriber.subscribe();
         return dispatcher.asObservable;
-    };
-    RXOperator.prototype.onReceive = function (f) {
-        var subscriber = new RXSubscriber(this.pipeline);
+    }
+    onReceive(f) {
+        const subscriber = new RXSubscriber(this.pipeline);
         this.child = subscriber;
         return subscriber.onReceive(f);
-    };
-    RXOperator.prototype.onError = function (f) {
-        var subscriber = new RXSubscriber(this.pipeline);
+    }
+    onError(f) {
+        const subscriber = new RXSubscriber(this.pipeline);
         this.child = subscriber;
         return subscriber.onError(f);
-    };
-    RXOperator.prototype.onComplete = function (f) {
-        var subscriber = new RXSubscriber(this.pipeline);
+    }
+    onComplete(f) {
+        const 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 };
+export class RXMap extends RXOperator {
+    constructor(pipe, mapper) {
+        super(pipe);
+        this.mapper = mapper;
+    }
+    send(value, broadcast) {
+        const newValue = this.mapper(value);
+        super.send(newValue, broadcast);
+    }
+}
 //--------------------------------------
 //  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;
+export class RXFlatMap extends RXOperator {
+    constructor(pipe, mapper) {
+        super(pipe);
+        this.mapper = mapper;
+    }
+    send(value, broadcast) {
         if (this.isComplete)
             return;
         this.mapper(value).pipe()
-            .onReceive(function (v) {
-            _super.prototype.send.call(_this, v, broadcast);
+            .onReceive(v => {
+            super.send(v, broadcast);
         })
-            .onError(function (e) {
-            _this.sendError(e, broadcast);
+            .onError((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 });
+    }
+}
+export class RXForEach extends RXOperator {
+    constructor(pipe, mapper) {
+        super(pipe);
+        this.buffer = Array();
+        this.willComplete = false;
+        this.willCompleteBroadcast = false;
+        this.curOp = new RXJustComplete();
+        this.mapper = mapper;
+    }
+    send(value, broadcast) {
+        this.buffer.push({ hasError: false, value, broadcast });
         this.processNext();
-    };
-    RXForEach.prototype.sendError = function (error, broadcast) {
-        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+    }
+    sendError(error, broadcast) {
+        this.buffer.push({ hasError: true, error, broadcast });
         this.processNext();
-    };
-    RXForEach.prototype.sendComplete = function (broadcast) {
+    }
+    sendComplete(broadcast) {
         this.willComplete = true;
         this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
         this.processNext();
-    };
-    RXForEach.prototype.processNext = function () {
-        var _this = this;
+    }
+    processNext() {
         if (!this.curOp.isComplete)
             return;
-        var notification = this.buffer.shift();
+        const notification = this.buffer.shift();
         if (notification) {
             if (notification.hasError) {
-                _super.prototype.sendError.call(this, notification.error, notification.broadcast);
+                super.sendError(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);
+                    .onReceive(v => {
+                    super.send(v, notification.broadcast);
                 })
-                    .onError(function (e) {
-                    _super.prototype.sendError.call(_this, e, notification.broadcast);
+                    .onError((e) => {
+                    super.sendError(e, notification.broadcast);
                 })
-                    .onComplete(function () { _this.processNext(); })
+                    .onComplete(() => { this.processNext(); })
                     .subscribe();
             }
             else {
@@ -220,56 +184,51 @@ var RXForEach = /** @class */ (function (_super) {
         }
         else {
             if (this.willComplete)
-                _super.prototype.sendComplete.call(this, this.willCompleteBroadcast);
+                super.sendComplete(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 });
+    }
+}
+export class RXSequent extends RXOperator {
+    constructor(pipe, mapper) {
+        super(pipe);
+        this.buffer = Array();
+        this.willComplete = false;
+        this.willCompleteBroadcast = false;
+        this.curOp = new RXJustComplete();
+        this.mapper = mapper;
+    }
+    send(value, broadcast) {
+        this.buffer.push({ hasError: false, value, broadcast });
         this.processNext();
-    };
-    RXSequent.prototype.sendError = function (error, broadcast) {
-        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+    }
+    sendError(error, broadcast) {
+        this.buffer.push({ hasError: true, error, broadcast });
         this.processNext();
-    };
-    RXSequent.prototype.sendComplete = function (broadcast) {
+    }
+    sendComplete(broadcast) {
         this.willComplete = true;
         this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
         this.processNext();
-    };
-    RXSequent.prototype.processNext = function () {
-        var _this = this;
+    }
+    processNext() {
         if (!this.curOp.isComplete)
             return;
-        var notification = this.buffer.shift();
+        const notification = this.buffer.shift();
         if (notification) {
             if (notification.hasError) {
-                _super.prototype.sendError.call(this, notification.error, notification.broadcast);
+                super.sendError(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);
+                    .onReceive(v => {
+                    super.send(v, notification.broadcast);
                 })
-                    .onError(function (e) {
-                    _super.prototype.sendError.call(_this, e, notification.broadcast);
+                    .onError((e) => {
+                    super.sendError(e, notification.broadcast);
                 })
-                    .onComplete(function () { _this.processNext(); })
+                    .onComplete(() => { this.processNext(); })
                     .subscribe();
             }
             else {
@@ -278,204 +237,161 @@ var RXSequent = /** @class */ (function (_super) {
         }
         else {
             if (this.willComplete)
-                _super.prototype.sendComplete.call(this, this.willCompleteBroadcast);
+                super.sendComplete(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;
+export class RXParallel extends RXOperator {
+    constructor(pipe, mapper) {
+        super(pipe);
+        this.willComplete = false;
+        this.willCompleteBroadcast = false;
+        this.activeOperations = 0;
+        this.mapper = mapper;
+    }
+    send(value, broadcast) {
         this.activeOperations++;
         this.mapper(value).pipe()
-            .onReceive(function (v) {
-            _super.prototype.send.call(_this, v, broadcast);
+            .onReceive(v => {
+            super.send(v, broadcast);
         })
-            .onError(function (e) {
-            _super.prototype.sendError.call(_this, e, broadcast);
+            .onError((e) => {
+            super.sendError(e, broadcast);
         })
-            .onComplete(function () {
-            _this.activeOperations--;
-            if (_this.activeOperations === 0 && _this.willComplete)
-                _super.prototype.sendComplete.call(_this, _this.willCompleteBroadcast);
+            .onComplete(() => {
+            this.activeOperations--;
+            if (this.activeOperations === 0 && this.willComplete)
+                super.sendComplete(this.willCompleteBroadcast);
         })
             .subscribe();
-    };
-    RXParallel.prototype.sendComplete = function (broadcast) {
+    }
+    sendComplete(broadcast) {
         this.willComplete = true;
         this.willCompleteBroadcast || (this.willCompleteBroadcast = broadcast);
         if (this.activeOperations === 0) {
-            _super.prototype.sendComplete.call(this, broadcast);
+            super.sendComplete(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) {
+export class RXFilter extends RXOperator {
+    constructor(pipe, predicate) {
+        super(pipe);
+        this.predicate = predicate;
+    }
+    send(value, broadcast) {
         if (this.predicate(value))
-            _super.prototype.send.call(this, value, broadcast);
-    };
-    return RXFilter;
-}(RXOperator));
-export { RXFilter };
+            super.send(value, broadcast);
+    }
+}
 //--------------------------------------
 //  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;
+export class RXSpread extends RXOperator {
+    send(value, broadcast) {
         if (Array.isArray(value)) {
-            value.forEach(function (v) {
-                _super.prototype.send.call(_this, v, broadcast);
+            value.forEach(v => {
+                super.send(v, broadcast);
             });
         }
         else
-            _super.prototype.send.call(this, value, broadcast);
-    };
-    return RXSpread;
-}(RXOperator));
-export { RXSpread };
+            super.send(value, broadcast);
+    }
+}
 //--------------------------------------
 //  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) {
+export class RXSkipFirst extends RXOperator {
+    send(value, broadcast) {
         if (broadcast)
-            _super.prototype.send.call(this, value, broadcast);
-    };
-    return RXSkipFirst;
-}(RXOperator));
-export { RXSkipFirst };
+            super.send(value, broadcast);
+    }
+}
 //--------------------------------------
 //  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) {
+export class RXSkipNullable extends RXOperator {
+    send(value, broadcast) {
         if (value !== null && value !== undefined)
-            _super.prototype.send.call(this, value, broadcast);
-    };
-    return RXSkipNullable;
-}(RXOperator));
-export { RXSkipNullable };
+            super.send(value, broadcast);
+    }
+}
 //--------------------------------------
 //  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) {
+export class RXRemoveDuplicates extends RXOperator {
+    constructor(pipe, value) {
+        super(pipe);
+        this.prevValue = undefined;
+        this.prevValue = value;
+    }
+    send(value, broadcast) {
         if (this.prevValue !== value) {
             this.prevValue = value;
-            _super.prototype.send.call(this, value, broadcast);
+            super.send(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;
+    }
+}
+export class RXDebounce extends RXOperator {
+    constructor(pipe, ms) {
+        super(pipe);
+        this.buffer = Array();
+        this.willComplete = false;
+        this.willCompleteBroadcast = false;
+        this.timeoutId = undefined;
+        this.ms = ms;
+    }
+    startTimer() {
         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];
+        this.timeoutId = setTimeout(() => {
+            this.timeoutId = undefined;
+            for (let i = this.buffer.length - 1; i >= 0; i--) {
+                const notification = this.buffer[i];
                 if (notification.hasError) {
-                    _super.prototype.sendError.call(_this, notification.error, notification.broadcast);
+                    super.sendError(notification.error, notification.broadcast);
                 }
                 else {
-                    _super.prototype.send.call(_this, notification.value, notification.broadcast);
+                    super.send(notification.value, notification.broadcast);
                 }
                 //if (notification.broadcast) break
                 break;
             }
-            _this.buffer.length = 0;
-            if (_this.willComplete)
-                _super.prototype.sendComplete.call(_this, _this.willCompleteBroadcast);
+            this.buffer.length = 0;
+            if (this.willComplete)
+                super.sendComplete(this.willCompleteBroadcast);
         }, this.ms);
-    };
-    RXDebounce.prototype.send = function (value, broadcast) {
-        this.buffer.push({ hasError: false, value: value, broadcast: broadcast });
+    }
+    send(value, broadcast) {
+        this.buffer.push({ hasError: false, value, broadcast });
         this.startTimer();
-    };
-    RXDebounce.prototype.sendError = function (error, broadcast) {
-        this.buffer.push({ hasError: true, error: error, broadcast: broadcast });
+    }
+    sendError(error, broadcast) {
+        this.buffer.push({ hasError: true, error, broadcast });
         this.startTimer();
-    };
-    RXDebounce.prototype.sendComplete = function (broadcast) {
+    }
+    sendComplete(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 };
+export class RXReplaceError extends RXOperator {
+    constructor(pipe, replaceWith) {
+        super(pipe);
+        this.replaceWith = replaceWith;
+    }
+    sendError(e, broadcast) {
+        const value = this.replaceWith(e);
+        value ? this.send(value, broadcast) : super.sendError(e, broadcast);
+    }
+}