evg_observable 1.1.31 → 1.1.33

package/package.json

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

package/src/outLib/Collector.js

@@ -19,7 +19,7 @@ class Collector {
         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();
@@ -172,14 +174,13 @@ class Observable {
     unSubscribe(listener) {
         if (this._isDestroyed)
             return;
-        if (this.isNextProcess) {
+        if (this.isNextProcess && listener) {
             const marker = listener;
             !marker.isMarkedForUnsubscribe && this.listenersForUnsubscribe.push(listener);
             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;
@@ -190,12 +191,7 @@ class Observable {
     unsubscribeAll() {
         if (this._isDestroyed)
             return;
-        const listeners = this.listeners;
-        const length = listeners.length;
-        for (let i = 0; i < length; i++) {
-            const subscriber = listeners.pop();
-            subscriber && subscriber.unsubscribe();
-        }
+        this.listeners.length = 0;
     }
     getValue() {
         if (this._isDestroyed)
@@ -212,14 +208,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>;
@@ -13,7 +13,7 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> {
     emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
 }
 export declare class OrderedObservable<T> extends Observable<T> implements IOrdered<T> {
-    sortByOrder(): void;
+    sortByOrder(): boolean;
     subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T> | undefined;
     pipe(): IOrderedSetup<T> | undefined;
 }

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;
@@ -45,7 +45,7 @@ exports.OrderedSubscribeObject = OrderedSubscribeObject;
 class OrderedObservable extends Observable_1.Observable {
     sortByOrder() {
         if (this._isDestroyed)
-            return undefined;
+            return false;
         this.listeners.sort((a, b) => {
             if (a.order > b.order)
                 return 1;
@@ -53,20 +53,21 @@ class OrderedObservable extends Observable_1.Observable {
                 return -1;
             return 0;
         });
+        return true;
     }
     subscribe(listener) {
         if (this._isDestroyed)
             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;
     }

package/src/outLib/Types.d.ts

@@ -91,7 +91,7 @@ export type ICollector = IDestroy & ISubscribeCounter & {
     unsubscribeAll(): void;
 };
 export type IOrderedObservable = {
-    sortByOrder(): void;
+    sortByOrder(): boolean;
 };
 export type IOrdered<T> = IObserver<T> & IOrderedObservable;
 export type IOrderedSubscriptionLike<T> = (ISubscriptionLike<T> & IOrder);