evg_observable 1.1.31 → 1.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.1.31",
+  "version": "1.1.32",
   "description": "Light observable",
   "directories": {
     "test": "test"

package/src/outLib/Collector.js

@@ -16,10 +16,9 @@ class Collector {
         }
     }
     unsubscribe(subscriptionLike) {
-        if (this._isDestroyed)
-            return null;
+        if (this._isDestroyed) return null;
         subscriptionLike && subscriptionLike.unsubscribe();
-        (0, FunctionLibs_1.deleteFromArray)(this.list, subscriptionLike);
+        FunctionLibs_1.deleteFromArray(this.list, subscriptionLike);
     }
     unsubscribeAll() {
         if (this._isDestroyed)

package/src/outLib/Observable.d.ts

@@ -11,7 +11,8 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedF
     private emitByNegativeCondition;
     private emitByPositiveCondition;
     private emitMatchCondition;
-    constructor(observable?: IObserver<T>, listener?: IListener<T>);
+    protected isPipe: boolean;
+    constructor(observable?: IObserver<T>, listener?: IListener<T>, isPipe?: boolean);
     private static callbackSend;
     subscribe(listener: IListener<T>): ISubscriptionLike<T>;
     unsubscribe(): void;

package/src/outLib/Observable.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = exports.SubscribeObject = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
 class SubscribeObject {
-    constructor(observable, listener) {
+    constructor(observable, listener, isPipe) {
         this.isMarkedForUnsubscribe = false;
         this._order = 0;
         this.isListenPaused = false;
@@ -13,22 +13,26 @@ class SubscribeObject {
         this.emitByNegativeCondition = null;
         this.emitByPositiveCondition = null;
         this.emitMatchCondition = null;
+        this.isPipe = false;
         this.observable = observable;
         this.listener = listener;
+        this.isPipe = !!isPipe;
     }
     static callbackSend(value, subsObj) {
         const listener = subsObj.listener;
+        if (!listener || !subsObj.observable) {
+            subsObj.unsubscribe();
+            return;
+        }
         switch (true) {
-            case !subsObj.observable:
-            case !listener:
-                subsObj.unsubscribe();
-                return;
             case subsObj.isListenPaused:
-                ;
+                return;
+            case !subsObj.isPipe:
+                listener(value);
                 return;
             case subsObj.once.isOnce:
                 subsObj.once.isFinished = true;
-                listener && listener((value));
+                listener(value);
                 subsObj.unsubscribe();
                 break;
             case !!subsObj.unsubscribeByNegativeCondition:
@@ -37,7 +41,7 @@ class SubscribeObject {
                     subsObj.unsubscribe();
                     return;
                 }
-                listener && listener((value));
+                listener(value);
                 break;
             case !!subsObj.unsubscribeByPositiveCondition:
                 if (subsObj.unsubscribeByPositiveCondition()) {
@@ -45,19 +49,17 @@ class SubscribeObject {
                     subsObj.unsubscribe();
                     return;
                 }
-                listener && listener((value));
+                listener(value);
                 break;
             case !!subsObj.emitByNegativeCondition:
-                !subsObj.emitByNegativeCondition() && listener && listener(value);
+                !subsObj.emitByNegativeCondition() && listener(value);
                 break;
             case !!subsObj.emitByPositiveCondition:
-                subsObj.emitByPositiveCondition() && listener && listener(value);
+                subsObj.emitByPositiveCondition() && listener(value);
                 break;
             case !!subsObj.emitMatchCondition:
-                (subsObj.emitMatchCondition() === value) && listener && listener(value);
+                (subsObj.emitMatchCondition() === value) && listener(value);
                 break;
-            default:
-                listener && listener((value));
         }
     }
     subscribe(listener) {
@@ -156,7 +158,7 @@ class Observable {
         const length = this.listeners.length;
         for (let i = 0; i < length; i++) {
             const listener = this.listeners[i];
-            listener && listener.send(value);
+            listener.send(value);
         }
         this.isNextProcess = false;
         this.listenersForUnsubscribe.length && this.handleListenersForUnsubscribe();
@@ -178,8 +180,7 @@ class Observable {
             marker.isMarkedForUnsubscribe = true;
             return;
         }
-        this.listeners &&
-            !(0, FunctionLibs_1.deleteFromArray)(this.listeners, listener);
+        this.listeners && FunctionLibs_1.deleteFromArray(this.listeners, listener);
     }
     destroy() {
         this.value = 0;
@@ -212,14 +213,14 @@ class Observable {
             return undefined;
         if (!listener)
             return undefined;
-        const subscribeObject = new SubscribeObject(this, listener);
+        const subscribeObject = new SubscribeObject(this, listener, false);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new SubscribeObject(this);
+        const subscribeObject = new SubscribeObject(this, undefined, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }

package/src/outLib/OrderedObservable.d.ts

@@ -1,7 +1,7 @@
 import { Observable, SubscribeObject } from "./Observable";
 import { ICallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike } from "./Types";
 export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> {
-    constructor(observable: OrderedObservable<T> | IOrdered<T>, listener?: IListener<T>);
+    constructor(observable: OrderedObservable<T> | IOrdered<T>, listener?: IListener<T>, isPipe?: boolean);
     get order(): number;
     set order(value: number);
     subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;

package/src/outLib/OrderedObservable.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderedObservable = exports.OrderedSubscribeObject = void 0;
 const Observable_1 = require("./Observable");
 class OrderedSubscribeObject extends Observable_1.SubscribeObject {
-    constructor(observable, listener) {
-        super(observable, listener);
+    constructor(observable, listener, isPipe) {
+        super(observable, listener, isPipe);
     }
     get order() {
         return this._order;
@@ -59,14 +59,14 @@ class OrderedObservable extends Observable_1.Observable {
             return undefined;
         if (!listener)
             return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, listener);
+        const subscribeObject = new OrderedSubscribeObject(this, listener, false);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this);
+        const subscribeObject = new OrderedSubscribeObject(this, undefined, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }