flinker 2.0.0 → 2.0.1

package/dist/esm/RXPublisher.js

@@ -1,18 +1,3 @@
-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 { RXPipeline } from './RXPipeline';
 //WeakRef is not supported in RN
 // export class RXPipelineGarbage {
@@ -31,14 +16,14 @@ import { RXPipeline } from './RXPipeline';
 //     Logger.i('GC: disposed pipelines:', disposedCount + '/' + this.total)
 //   }
 // }
-var generateSUID = (function () {
-    var value = 0;
-    return function () {
+const generateSUID = (() => {
+    let value = 0;
+    return () => {
         return value++;
     };
 })();
-var RXPublisher = /** @class */ (function () {
-    function RXPublisher() {
+export class RXPublisher {
+    constructor() {
         this.suid = generateSUID();
         this.type = 'observable';
         this._isComplete = false;
@@ -49,287 +34,230 @@ var RXPublisher = /** @class */ (function () {
         this.isSending = false;
         this.pipelines = Array();
     }
-    Object.defineProperty(RXPublisher.prototype, "volume", {
-        get: function () { return this.pipelines.length; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXPublisher.prototype, "asObservable", {
-        get: function () { return this; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXPublisher.prototype, "isComplete", {
-        get: function () { return this._isComplete; },
-        enumerable: false,
-        configurable: true
-    });
-    RXPublisher.prototype.pipe = function () {
-        var pipe = new RXPipeline(this);
+    get volume() { return this.pipelines.length; }
+    get asObservable() { return this; }
+    get isComplete() { return this._isComplete; }
+    pipe() {
+        const pipe = new RXPipeline(this);
         this.pipelines.push(pipe);
         //RXPipelineGarbage.self.register(pipe)
         return pipe.asOperator;
-    };
-    RXPublisher.prototype.didSubscribe = function (p) {
+    }
+    didSubscribe(p) {
         this.isComplete && p.sendComplete(false);
-    };
-    RXPublisher.prototype.didUnsubscribe = function (p) {
+    }
+    didUnsubscribe(p) {
         if (this.isSending) {
             this.pendingUnsubscribePipes.push(p);
             return;
         }
-        var index = this.pipelines.indexOf(p);
+        const index = this.pipelines.indexOf(p);
         index !== -1 && this.pipelines.splice(index, 1);
-    };
-    RXPublisher.prototype.send = function (value) {
+    }
+    send(value) {
         this.isSending = true;
-        this.pipelines.forEach(function (i) { i.send(value, true); });
+        this.pipelines.forEach(i => { i.send(value, true); });
         this.isSending = false;
         this.runPendingOperations();
-    };
-    RXPublisher.prototype.sendError = function (e) {
+    }
+    sendError(e) {
         this.isSending = true;
-        this.pipelines.forEach(function (i) { i.sendError(e, true); });
+        this.pipelines.forEach(i => { i.sendError(e, true); });
         this.isSending = false;
         this.runPendingOperations();
-    };
-    RXPublisher.prototype.sendComplete = function () {
+    }
+    sendComplete() {
         this.isSending = true;
         this._isComplete = true;
-        this.pipelines.forEach(function (i) { i.sendComplete(true); });
+        this.pipelines.forEach(i => { i.sendComplete(true); });
         this.pipelines.length = 0;
         this.isSending = false;
         this.runPendingOperations();
-    };
-    RXPublisher.prototype.runPendingOperations = function () {
-        var _this = this;
+    }
+    runPendingOperations() {
         if (this.isSending)
             return;
         if (this.pendingUnsubscribePipes.length > 0) {
-            this.pendingUnsubscribePipes.forEach(function (p) { _this.didUnsubscribe(p); });
+            this.pendingUnsubscribePipes.forEach(p => { this.didUnsubscribe(p); });
             this.pendingUnsubscribePipes.length = 0;
         }
-    };
-    return RXPublisher;
-}());
-export { RXPublisher };
+    }
+}
 //--------------------------------------
 //  RXJustComplete
 //--------------------------------------
-var RXJustComplete = /** @class */ (function (_super) {
-    __extends(RXJustComplete, _super);
-    function RXJustComplete(value) {
-        var _this = _super.call(this) || this;
-        _this.value = value;
-        value !== undefined && _this.send(value);
-        _this.sendComplete();
-        return _this;
-    }
-    RXJustComplete.prototype.didSubscribe = function (p) {
+export class RXJustComplete extends RXPublisher {
+    constructor(value) {
+        super();
+        this.value = value;
+        value !== undefined && this.send(value);
+        this.sendComplete();
+    }
+    didSubscribe(p) {
         this.isComplete && this.value !== undefined && p.send(this.value, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXJustComplete;
-}(RXPublisher));
-export { RXJustComplete };
+    }
+}
 //--------------------------------------
 //  RXJustError
 //--------------------------------------
-var RXJustError = /** @class */ (function (_super) {
-    __extends(RXJustError, _super);
-    function RXJustError(error) {
-        var _this = _super.call(this) || this;
-        _this.error = error;
-        _this.sendError(error);
-        _this.sendComplete();
-        return _this;
-    }
-    RXJustError.prototype.didSubscribe = function (p) {
+export class RXJustError extends RXPublisher {
+    constructor(error) {
+        super();
+        this.error = error;
+        this.sendError(error);
+        this.sendComplete();
+    }
+    didSubscribe(p) {
         this.isComplete && p.sendError(this.error, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXJustError;
-}(RXPublisher));
-export { RXJustError };
+    }
+}
 //--------------------------------------
 //  RXDelayedComplete
 //--------------------------------------
-var RXDelayedComplete = /** @class */ (function (_super) {
-    __extends(RXDelayedComplete, _super);
-    function RXDelayedComplete(ms, value) {
-        var _this = _super.call(this) || this;
-        _this.value = value;
-        setTimeout(function () {
-            value !== undefined && _this.send(value);
-            _this.sendComplete();
+export class RXDelayedComplete extends RXPublisher {
+    constructor(ms, value) {
+        super();
+        this.value = value;
+        setTimeout(() => {
+            value !== undefined && this.send(value);
+            this.sendComplete();
         }, ms);
-        return _this;
     }
-    RXDelayedComplete.prototype.didSubscribe = function (p) {
+    didSubscribe(p) {
         this.isComplete && this.value !== undefined && p.send(this.value, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXDelayedComplete;
-}(RXPublisher));
-export { RXDelayedComplete };
+    }
+}
 //--------------------------------------
 //  RXDelayedError
 //--------------------------------------
-var RXDelayedError = /** @class */ (function (_super) {
-    __extends(RXDelayedError, _super);
-    function RXDelayedError(ms, error) {
-        var _this = _super.call(this) || this;
-        _this.error = error;
-        setTimeout(function () {
-            _this.sendError(error);
-            _this.sendComplete();
+export class RXDelayedError extends RXPublisher {
+    constructor(ms, error) {
+        super();
+        this.error = error;
+        setTimeout(() => {
+            this.sendError(error);
+            this.sendComplete();
         }, ms);
-        return _this;
     }
-    RXDelayedError.prototype.didSubscribe = function (p) {
+    didSubscribe(p) {
         this.isComplete && p.sendError(this.error, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXDelayedError;
-}(RXPublisher));
-export { RXDelayedError };
+    }
+}
 //--------------------------------------
 //  RXEmitter
 //--------------------------------------
-var RXEmitter = /** @class */ (function (_super) {
-    __extends(RXEmitter, _super);
-    function RXEmitter() {
-        var _this = _super.call(this) || this;
-        _this._hasValue = false;
-        _this.hasError = false;
-        _this._err = undefined;
-        return _this;
-    }
-    Object.defineProperty(RXEmitter.prototype, "value", {
-        get: function () { return this._value; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXEmitter.prototype, "err", {
-        get: function () { return this._err; },
-        enumerable: false,
-        configurable: true
-    });
-    RXEmitter.prototype.send = function (value) {
+export class RXEmitter extends RXPublisher {
+    get value() { return this._value; }
+    get err() { return this._err; }
+    constructor() {
+        super();
+        this._hasValue = false;
+        this.hasError = false;
+        this._err = undefined;
+    }
+    send(value) {
         if (this.isComplete)
             return;
         this._value = value;
         this._hasValue = true;
-        _super.prototype.send.call(this, value);
-    };
-    RXEmitter.prototype.sendError = function (e) {
+        super.send(value);
+    }
+    sendError(e) {
         if (this.isComplete)
             return;
         this._err = e;
         this.hasError = true;
-        _super.prototype.sendError.call(this, e);
-    };
-    RXEmitter.prototype.sendComplete = function () {
+        super.sendError(e);
+    }
+    sendComplete() {
         if (this.isComplete)
             return;
-        _super.prototype.sendComplete.call(this);
-    };
-    RXEmitter.prototype.didSubscribe = function (p) {
+        super.sendComplete();
+    }
+    didSubscribe(p) {
         this.hasError && p.sendError(this.err, false);
         !this.hasError && this._hasValue && p.send(this.value, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXEmitter;
-}(RXPublisher));
-export { RXEmitter };
+    }
+}
 //--------------------------------------
 //  RXSubject
 //--------------------------------------
-var RXSubject = /** @class */ (function (_super) {
-    __extends(RXSubject, _super);
-    function RXSubject(value) {
-        var _this = _super.call(this) || this;
-        _this._hasError = false;
-        _this._err = undefined;
-        _this._value = value;
-        return _this;
-    }
-    Object.defineProperty(RXSubject.prototype, "value", {
-        get: function () { return this._value; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXSubject.prototype, "err", {
-        get: function () {
-            return this._err;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RXSubject.prototype.send = function (value) {
+export class RXSubject extends RXPublisher {
+    get value() { return this._value; }
+    get err() {
+        return this._err;
+    }
+    constructor(value) {
+        super();
+        this._hasError = false;
+        this._err = undefined;
+        this._value = value;
+    }
+    send(value) {
         if (this.isComplete)
             return;
         this._value = value;
-        _super.prototype.send.call(this, value);
-    };
-    RXSubject.prototype.resend = function () {
-        _super.prototype.send.call(this, this.value);
-    };
-    RXSubject.prototype.sendError = function (e) {
+        super.send(value);
+    }
+    resend() {
+        super.send(this.value);
+    }
+    sendError(e) {
         if (this.isComplete)
             return;
         this._err = e;
         this._hasError = true;
-        _super.prototype.sendError.call(this, e);
-    };
-    RXSubject.prototype.sendComplete = function () {
+        super.sendError(e);
+    }
+    sendComplete() {
         if (this.isComplete)
             return;
         this._isComplete = true;
-        _super.prototype.sendComplete.call(this);
-    };
-    RXSubject.prototype.didSubscribe = function (p) {
+        super.sendComplete();
+    }
+    didSubscribe(p) {
         this._hasError && p.sendError(this.err, false);
         !this._hasError && p.send(this.value, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXSubject;
-}(RXPublisher));
-export { RXSubject };
+    }
+}
 //--------------------------------------
 //  RXBuffer
 //--------------------------------------
-var RXBuffer = /** @class */ (function (_super) {
-    __extends(RXBuffer, _super);
-    function RXBuffer() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.values = Array();
-        _this.errors = Array();
-        _this.isError = Array();
-        return _this;
-    }
-    RXBuffer.prototype.send = function (value) {
+export class RXBuffer extends RXPublisher {
+    constructor() {
+        super(...arguments);
+        this.values = Array();
+        this.errors = Array();
+        this.isError = Array();
+    }
+    send(value) {
         if (this.isComplete)
             return;
         this.values.push(value);
         this.isError.push(false);
-        _super.prototype.send.call(this, value);
-    };
-    RXBuffer.prototype.sendError = function (e) {
+        super.send(value);
+    }
+    sendError(e) {
         if (this.isComplete)
             return;
         this.errors.push(e);
         this.isError.push(true);
-        _super.prototype.sendError.call(this, e);
-    };
-    RXBuffer.prototype.sendComplete = function () {
+        super.sendError(e);
+    }
+    sendComplete() {
         if (this.isComplete)
             return;
         this._isComplete = true;
-        _super.prototype.sendComplete.call(this);
-    };
-    RXBuffer.prototype.didSubscribe = function (p) {
-        for (var i = 0, v = 0, e = 0; i < this.isError.length; i++) {
+        super.sendComplete();
+    }
+    didSubscribe(p) {
+        for (let i = 0, v = 0, e = 0; i < this.isError.length; i++) {
             if (this.isError[i]) {
                 e < this.errors.length && p.sendError(this.errors[e], false);
                 e++;
@@ -340,48 +268,36 @@ var RXBuffer = /** @class */ (function (_super) {
             }
         }
         this.isComplete && p.sendComplete(false);
-    };
-    return RXBuffer;
-}(RXPublisher));
-export { RXBuffer };
+    }
+}
 //--------------------------------------
 //  RXOperation
 //--------------------------------------
-var RXOperation = /** @class */ (function (_super) {
-    __extends(RXOperation, _super);
-    function RXOperation() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._value = undefined;
-        _this._hasError = false;
-        _this._err = undefined;
-        return _this;
-    }
-    Object.defineProperty(RXOperation.prototype, "value", {
-        get: function () { return this._value; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXOperation.prototype, "err", {
-        get: function () { return this._err; },
-        enumerable: false,
-        configurable: true
-    });
-    RXOperation.prototype.success = function (value) {
+export class RXOperation extends RXPublisher {
+    constructor() {
+        super(...arguments);
+        this._value = undefined;
+        this._hasError = false;
+        this._err = undefined;
+    }
+    get value() { return this._value; }
+    get err() { return this._err; }
+    success(value) {
         if (this.isComplete)
             return;
         this._value = value;
-        _super.prototype.send.call(this, value);
-        _super.prototype.sendComplete.call(this);
-    };
-    RXOperation.prototype.fail = function (e) {
+        super.send(value);
+        super.sendComplete();
+    }
+    fail(e) {
         if (this.isComplete)
             return;
         this._err = e;
         this._hasError = true;
-        _super.prototype.sendError.call(this, e);
-        _super.prototype.sendComplete.call(this);
-    };
-    RXOperation.prototype.didSubscribe = function (p) {
+        super.sendError(e);
+        super.sendComplete();
+    }
+    didSubscribe(p) {
         if (!this.isComplete)
             return;
         if (this._hasError) {
@@ -392,173 +308,139 @@ var RXOperation = /** @class */ (function (_super) {
             p.send(this.value, false);
             p.sendComplete(false);
         }
-    };
-    return RXOperation;
-}(RXPublisher));
-export { RXOperation };
+    }
+}
 //--------------------------------------
 //  RXCombine
 //--------------------------------------
-var RXCombine = /** @class */ (function (_super) {
-    __extends(RXCombine, _super);
-    function RXCombine(list) {
-        var _this = _super.call(this) || this;
-        _this._values = [];
-        _this._hasError = false;
-        _this._err = undefined;
-        var count = list.length;
-        _this._values = new Array(list.length).fill(undefined);
-        list.forEach(function (rx, ind) {
-            var op = rx instanceof RXPublisher ? rx.asObservable.pipe() : rx;
-            op.onReceive(function (v) {
-                _this.values[ind] = v;
-                _super.prototype.send.call(_this, _this.values);
+export class RXCombine extends RXPublisher {
+    get values() { return this._values; }
+    get err() { return this._err; }
+    constructor(list) {
+        super();
+        this._values = [];
+        this._hasError = false;
+        this._err = undefined;
+        let count = list.length;
+        this._values = new Array(list.length).fill(undefined);
+        list.forEach((rx, ind) => {
+            const op = rx instanceof RXPublisher ? rx.asObservable.pipe() : rx;
+            op.onReceive(v => {
+                this.values[ind] = v;
+                super.send(this.values);
             })
-                .onError(function (e) {
-                _this._err = e;
-                _this._hasError = true;
-                _super.prototype.sendError.call(_this, e);
+                .onError((e) => {
+                this._err = e;
+                this._hasError = true;
+                super.sendError(e);
             })
-                .onComplete(function () {
+                .onComplete(() => {
                 count--;
                 if (count === 0) {
-                    _this._isComplete = true;
-                    _super.prototype.sendComplete.call(_this);
+                    this._isComplete = true;
+                    super.sendComplete();
                 }
             })
                 .subscribe();
         });
         if (count === 0) {
-            _super.prototype.sendComplete.call(_this);
+            super.sendComplete();
         }
-        return _this;
-    }
-    Object.defineProperty(RXCombine.prototype, "values", {
-        get: function () { return this._values; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXCombine.prototype, "err", {
-        get: function () { return this._err; },
-        enumerable: false,
-        configurable: true
-    });
-    RXCombine.prototype.didSubscribe = function (p) {
+    }
+    didSubscribe(p) {
         !this._hasError && p.send(this.values, false);
         this._hasError && p.sendError(this.err, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXCombine;
-}(RXPublisher));
-export { RXCombine };
+    }
+}
 //--------------------------------------
 //  RXFrom
 //--------------------------------------
-var RXFrom = /** @class */ (function (_super) {
-    __extends(RXFrom, _super);
-    function RXFrom(list) {
-        var _this = _super.call(this) || this;
-        _this.values = list;
-        _this.sendComplete();
-        return _this;
-    }
-    RXFrom.prototype.didSubscribe = function (p) {
-        this.values.forEach(function (v) { p.send(v, false); });
+export class RXFrom extends RXPublisher {
+    constructor(list) {
+        super();
+        this.values = list;
+        this.sendComplete();
+    }
+    didSubscribe(p) {
+        this.values.forEach(v => { p.send(v, false); });
         p.sendComplete(false);
-    };
-    return RXFrom;
-}(RXPublisher));
-export { RXFrom };
+    }
+}
 //--------------------------------------
 //  RXWaitUntilComplete
 //--------------------------------------
 /*
   * wait until all publishers are complete and then send a value of the last publisher if it's specified
   * */
-var RXWaitUntilComplete = /** @class */ (function (_super) {
-    __extends(RXWaitUntilComplete, _super);
-    function RXWaitUntilComplete(list, resultPublisher) {
-        var _this = _super.call(this) || this;
-        _this._value = undefined;
-        _this._hasError = false;
-        _this._err = undefined;
-        _this._resultPublisher = resultPublisher;
-        var count = Array.isArray(list) ? list.length : 1;
+export class RXWaitUntilComplete extends RXPublisher {
+    get value() { return this._value; }
+    get err() { return this._err; }
+    constructor(list, resultPublisher) {
+        super();
+        this._value = undefined;
+        this._hasError = false;
+        this._err = undefined;
+        this._resultPublisher = resultPublisher;
+        let count = Array.isArray(list) ? list.length : 1;
         if (Array.isArray(list)) {
-            list.forEach(function (ob) {
-                return ob.pipe()
-                    .onError(function (e) {
-                    _this._err = e;
-                    _this._hasError = true;
-                    _super.prototype.sendError.call(_this, e);
-                })
-                    .onComplete(function () {
-                    count--;
-                    if (count === 0)
-                        _this.subscribeToResultPublisher();
-                })
-                    .subscribe();
-            });
+            list.forEach(ob => ob.pipe()
+                .onError(e => {
+                this._err = e;
+                this._hasError = true;
+                super.sendError(e);
+            })
+                .onComplete(() => {
+                count--;
+                if (count === 0)
+                    this.subscribeToResultPublisher();
+            })
+                .subscribe());
             if (count === 0)
-                _this.subscribeToResultPublisher();
+                this.subscribeToResultPublisher();
         }
         else {
             list.pipe()
-                .onError(function (e) {
-                _this._err = e;
-                _this._hasError = true;
-                _super.prototype.sendError.call(_this, e);
+                .onError(e => {
+                this._err = e;
+                this._hasError = true;
+                super.sendError(e);
             })
-                .onComplete(function () {
-                _this.subscribeToResultPublisher();
+                .onComplete(() => {
+                this.subscribeToResultPublisher();
             })
                 .subscribe();
         }
-        return _this;
-    }
-    Object.defineProperty(RXWaitUntilComplete.prototype, "value", {
-        get: function () { return this._value; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXWaitUntilComplete.prototype, "err", {
-        get: function () { return this._err; },
-        enumerable: false,
-        configurable: true
-    });
-    RXWaitUntilComplete.prototype.subscribeToResultPublisher = function () {
-        var _this = this;
+    }
+    subscribeToResultPublisher() {
         if (this._resultPublisher) {
             this._resultPublisher.pipe()
-                .onReceive(function (v) {
-                _this._value = v;
-                _super.prototype.send.call(_this, v);
+                .onReceive(v => {
+                this._value = v;
+                super.send(v);
             })
-                .onError(function (e) {
-                _this._err = e;
-                _this._hasError = true;
-                _super.prototype.sendError.call(_this, e);
+                .onError((e) => {
+                this._err = e;
+                this._hasError = true;
+                super.sendError(e);
             })
-                .onComplete(function () {
-                _this._isComplete = true;
-                _super.prototype.sendComplete.call(_this);
+                .onComplete(() => {
+                this._isComplete = true;
+                super.sendComplete();
             })
                 .subscribe();
         }
         else {
             this._isComplete = true;
-            _super.prototype.sendComplete.call(this);
+            super.sendComplete();
         }
-    };
-    RXWaitUntilComplete.prototype.didSubscribe = function (p) {
-        var _a;
-        !this._hasError && this.isComplete && ((_a = this._resultPublisher) === null || _a === void 0 ? void 0 : _a.isComplete) && p.send(this.value, false);
+    }
+    didSubscribe(p) {
+        !this._hasError && this.isComplete && this._resultPublisher?.isComplete && p.send(this.value, false);
         this._hasError && p.sendError(this.err, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXWaitUntilComplete;
-}(RXPublisher));
-export { RXWaitUntilComplete };
+    }
+}
 /*
 *
 * UI
@@ -567,57 +449,43 @@ export { RXWaitUntilComplete };
 //--------------------------------------
 //  RXObservableEntity
 //--------------------------------------
-var RXObservableEntity = /** @class */ (function (_super) {
-    __extends(RXObservableEntity, _super);
-    function RXObservableEntity() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    RXObservableEntity.prototype.mutated = function () {
+export class RXObservableEntity extends RXPublisher {
+    mutated() {
         this.send(this);
-    };
-    RXObservableEntity.prototype.send = function (value) {
-        _super.prototype.send.call(this, value);
-    };
-    RXObservableEntity.prototype.dispose = function () {
+    }
+    send(value) {
+        super.send(value);
+    }
+    dispose() {
         this.sendComplete();
-    };
-    RXObservableEntity.prototype.didSubscribe = function (p) {
+    }
+    didSubscribe(p) {
         p.send(this, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXObservableEntity;
-}(RXPublisher));
-export { RXObservableEntity };
+    }
+}
 //--------------------------------------
 //  RXMutableValue
 //--------------------------------------
-var RXObservableValue = /** @class */ (function (_super) {
-    __extends(RXObservableValue, _super);
-    function RXObservableValue(value) {
-        var _this = _super.call(this) || this;
-        _this._value = value;
-        return _this;
-    }
-    Object.defineProperty(RXObservableValue.prototype, "value", {
-        get: function () { return this._value; },
-        set: function (value) {
-            if (value !== this._value) {
-                this._value = value;
-                _super.prototype.send.call(this, value);
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    RXObservableValue.prototype.didSubscribe = function (p) {
+export class RXObservableValue extends RXPublisher {
+    get value() { return this._value; }
+    set value(value) {
+        if (value !== this._value) {
+            this._value = value;
+            super.send(value);
+        }
+    }
+    constructor(value) {
+        super();
+        this._value = value;
+    }
+    didSubscribe(p) {
         p.send(this.value, false);
         this.isComplete && p.sendComplete(false);
-    };
-    return RXObservableValue;
-}(RXPublisher));
-export { RXObservableValue };
-var RXQueueOperator = /** @class */ (function () {
-    function RXQueueOperator(op) {
+    }
+}
+export class RXQueueOperator {
+    constructor(op) {
         this.inProgress = true;
         this.value = undefined;
         this.op = op;
@@ -625,98 +493,78 @@ var RXQueueOperator = /** @class */ (function () {
     //--------------------------------------
     //  RXSender Protocol
     //--------------------------------------
-    RXQueueOperator.prototype.send = function (value) {
-        var _a;
+    send(value) {
         if (!this.op.isComplete) {
-            (_a = this.child) === null || _a === void 0 ? void 0 : _a.send(value);
+            this.child?.send(value);
         }
-    };
+    }
     //--------------------------------------
     //  OPERATORS
     //--------------------------------------
-    RXQueueOperator.prototype.next = function (f) {
-        var operator = this.addChild(new RXQueueNext(this.op, f));
+    next(f) {
+        const operator = this.addChild(new RXQueueNext(this.op, f));
         if (!this.inProgress) {
             operator.send(this.value);
         }
         return operator;
-    };
-    RXQueueOperator.prototype.addChild = function (op) {
+    }
+    addChild(op) {
         this.child = op;
         return op;
-    };
-    RXQueueOperator.prototype.complete = function () {
-        var _this = this;
+    }
+    complete() {
         if (!this.op.isComplete) {
-            this.next(function (res) {
-                _this.op.success(res);
-                return _this.op;
+            this.next(res => {
+                this.op.success(res);
+                return this.op;
             });
         }
         return this.op.asObservable;
-    };
-    return RXQueueOperator;
-}());
-export { RXQueueOperator };
-var RXQueueNext = /** @class */ (function (_super) {
-    __extends(RXQueueNext, _super);
-    function RXQueueNext(op, mapper) {
-        var _this = _super.call(this, op) || this;
-        _this.mapper = mapper;
-        return _this;
-    }
-    RXQueueNext.prototype.send = function (value) {
-        var _this = this;
+    }
+}
+class RXQueueNext extends RXQueueOperator {
+    constructor(op, mapper) {
+        super(op);
+        this.mapper = mapper;
+    }
+    send(value) {
         if (this.op.isComplete)
             return;
-        var rx = this.mapper(value);
+        const rx = this.mapper(value);
         rx.pipe()
-            .onReceive(function (v) {
-            _this.value = v;
+            .onReceive((v) => {
+            this.value = v;
         })
-            .onError(function (e) {
-            _this.op.fail(e);
+            .onError((e) => {
+            this.op.fail(e);
         })
-            .onComplete(function () {
-            _this.inProgress = false;
-            _super.prototype.send.call(_this, _this.value);
+            .onComplete(() => {
+            this.inProgress = false;
+            super.send(this.value);
         })
             .subscribe();
-    };
-    return RXQueueNext;
-}(RXQueueOperator));
-var RXQueue = /** @class */ (function (_super) {
-    __extends(RXQueue, _super);
-    function RXQueue() {
-        var _this = _super.call(this, new RXOperation()) || this;
-        _this.inProgress = false;
-        return _this;
-    }
-    Object.defineProperty(RXQueue.prototype, "asObservable", {
-        //--------------------------------------
-        //  asObservable
-        //--------------------------------------
-        get: function () { return this.op.asObservable; },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(RXQueue.prototype, "isComplete", {
-        //--------------------------------------
-        //  isComplete
-        //--------------------------------------
-        get: function () { return this.op.isComplete; },
-        enumerable: false,
-        configurable: true
-    });
-    RXQueue.prototype.next = function (f) {
-        return _super.prototype.next.call(this, f);
-    };
-    RXQueue.prototype.success = function (v) {
+    }
+}
+export class RXQueue extends RXQueueOperator {
+    constructor() {
+        super(new RXOperation());
+        this.inProgress = false;
+    }
+    //--------------------------------------
+    //  asObservable
+    //--------------------------------------
+    get asObservable() { return this.op.asObservable; }
+    //--------------------------------------
+    //  isComplete
+    //--------------------------------------
+    get isComplete() { return this.op.isComplete; }
+    next(f) {
+        return super.next(f);
+    }
+    success(v) {
         this.op.success(v);
-    };
-    RXQueue.prototype.fail = function (e) {
+    }
+    fail(e) {
         this.op.fail(e);
-    };
-    return RXQueue;
-}(RXQueueOperator));
-export { RXQueue };
+    }
+}