evg_observable 1.1.28 → 1.1.30

package/MIT

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2021 Grif
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.1.28",
+  "version": "1.1.30",
   "description": "Light observable",
   "main": "index.js",
   "directories": {
@@ -16,7 +16,7 @@
     "url": "git+https://github.com/BarushevEA/light-observable-ts.git"
   },
   "author": "Barushev E.A.",
-  "license": "LICENSE.md",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/BarushevEA/light-observable-ts/issues"
   },

package/src/outLib/Observable.d.ts

@@ -3,6 +3,7 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedF
     isMarkedForUnsubscribe: boolean;
     protected observable: IObserver<T> | undefined;
     protected listener: IListener<T> | undefined;
+    protected _order: number;
     private isListenPaused;
     private once;
     private unsubscribeByNegativeCondition;
@@ -10,13 +11,11 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedF
     private emitByNegativeCondition;
     private emitByPositiveCondition;
     private emitMatchCondition;
-    protected _order: number;
     constructor(observable?: IObserver<T>, listener?: IListener<T>);
-    private static asyncSend;
+    private static callbackSend;
     subscribe(listener: IListener<T>): ISubscriptionLike<T>;
     unsubscribe(): void;
     send(value: T): void;
-    private sendValueToListener;
     setOnce(): ISubscribe<T>;
     unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
     unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;

package/src/outLib/Observable.js

@@ -5,6 +5,7 @@ const FunctionLibs_1 = require("./FunctionLibs");
 class SubscribeObject {
     constructor(observable, listener) {
         this.isMarkedForUnsubscribe = false;
+        this._order = 0;
         this.isListenPaused = false;
         this.once = { isOnce: false, isFinished: false };
         this.unsubscribeByNegativeCondition = null;
@@ -12,77 +13,70 @@ class SubscribeObject {
         this.emitByNegativeCondition = null;
         this.emitByPositiveCondition = null;
         this.emitMatchCondition = null;
-        this._order = 0;
         this.observable = observable;
         this.listener = listener;
     }
-    static asyncSend(value, subsObj) {
+    static callbackSend(value, subsObj) {
         const listener = subsObj.listener;
-        return new Promise((resolve => {
-            switch (true) {
-                case !subsObj.observable:
-                case !listener:
+        switch (true) {
+            case !subsObj.observable:
+            case !listener:
+                subsObj.unsubscribe();
+                return;
+            case subsObj.isListenPaused:
+                return;
+            case subsObj.once.isOnce:
+                subsObj.once.isFinished = true;
+                listener && listener((value));
+                subsObj.unsubscribe();
+                break;
+            case !!subsObj.unsubscribeByNegativeCondition:
+                if (!subsObj.unsubscribeByNegativeCondition()) {
+                    subsObj.unsubscribeByNegativeCondition = null;
                     subsObj.unsubscribe();
-                    resolve(false);
-                    return;
-                case subsObj.isListenPaused:
-                    resolve(false);
                     return;
-                case subsObj.once.isOnce:
-                    subsObj.once.isFinished = true;
-                    listener && listener((value));
+                }
+                listener && listener((value));
+                break;
+            case !!subsObj.unsubscribeByPositiveCondition:
+                if (subsObj.unsubscribeByPositiveCondition()) {
+                    subsObj.unsubscribeByPositiveCondition = null;
                     subsObj.unsubscribe();
-                    break;
-                case !!subsObj.unsubscribeByNegativeCondition:
-                    if (!subsObj.unsubscribeByNegativeCondition()) {
-                        subsObj.unsubscribeByNegativeCondition = null;
-                        subsObj.unsubscribe();
-                        return;
-                    }
-                    listener && listener((value));
-                    break;
-                case !!subsObj.unsubscribeByPositiveCondition:
-                    if (subsObj.unsubscribeByPositiveCondition()) {
-                        subsObj.unsubscribeByPositiveCondition = null;
-                        subsObj.unsubscribe();
-                        return;
-                    }
-                    listener && listener((value));
-                    break;
-                case !!subsObj.emitByNegativeCondition:
-                    !subsObj.emitByNegativeCondition() && listener && listener(value);
-                    break;
-                case !!subsObj.emitByPositiveCondition:
-                    subsObj.emitByPositiveCondition() && listener && listener(value);
-                    break;
-                case !!subsObj.emitMatchCondition:
-                    (subsObj.emitMatchCondition() === value) && listener && listener(value);
-                    break;
-                default:
-                    listener && listener((value));
-            }
-            resolve(true);
-        }));
+                    return;
+                }
+                listener && listener((value));
+                break;
+            case !!subsObj.emitByNegativeCondition:
+                !subsObj.emitByNegativeCondition() && listener && listener(value);
+                break;
+            case !!subsObj.emitByPositiveCondition:
+                subsObj.emitByPositiveCondition() && listener && listener(value);
+                break;
+            case !!subsObj.emitMatchCondition:
+                (subsObj.emitMatchCondition() === value) && listener && listener(value);
+                break;
+            default:
+                listener && listener((value));
+        }
     }
     subscribe(listener) {
         this.listener = listener;
         return this;
     }
     unsubscribe() {
-        if (!!this.observable) {
+        if (this.observable) {
             this.observable.unSubscribe(this);
             this.observable = 0;
             this.listener = 0;
         }
     }
     send(value) {
-        this.sendValueToListener(value);
-    }
-    sendValueToListener(value) {
-        SubscribeObject.asyncSend(value, this)
-            .catch(err => {
-            console.log('(Unit of SubscribeObject).send(value: T) call .sendValueToListener(value: T) ERROR:', err);
-        });
+        try {
+            SubscribeObject.callbackSend(value, this);
+        }
+        catch (err) {
+            console.log('(Unit of SubscribeObject).send(value: T) ERROR:', err);
+        }
     }
     setOnce() {
         this.once.isOnce = true;
@@ -158,8 +152,8 @@ class Observable {
             return;
         this.value = value;
         this.isNextProcess = true;
-        for (let i = 0; i < this.listeners.length; i++)
-            this.listeners[i].send(value);
+        for (const listener of this.listeners)
+            listener && listener.send(value);
         this.isNextProcess = false;
         this.handleListenersForUnsubscribe();
     }
@@ -210,6 +204,8 @@ class Observable {
     subscribe(listener) {
         if (this._isDestroyed)
             return undefined;
+        if (!listener)
+            return undefined;
         const subscribeObject = new SubscribeObject(this, listener);
         this.listeners.push(subscribeObject);
         return subscribeObject;

package/src/outLib/OrderedObservable.d.ts

@@ -1,5 +1,5 @@
 import { Observable, SubscribeObject } from "./Observable";
-import { ICallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISubscriptionLike } from "./Types";
+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>);
     get order(): number;
@@ -14,6 +14,6 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> {
 }
 export declare class OrderedObservable<T> extends Observable<T> implements IOrdered<T> {
     sortByOrder(): void;
-    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
+    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T> | undefined;
     pipe(): IOrderedSetup<T> | undefined;
 }

package/src/outLib/OrderedObservable.js

@@ -57,6 +57,8 @@ class OrderedObservable extends Observable_1.Observable {
     subscribe(listener) {
         if (this._isDestroyed)
             return undefined;
+        if (!listener)
+            return undefined;
         const subscribeObject = new OrderedSubscribeObject(this, listener);
         this.listeners.push(subscribeObject);
         return subscribeObject;

package/src/outLib/Types.d.ts

@@ -94,7 +94,7 @@ export type IOrderedObservable = {
     sortByOrder(): void;
 };
 export type IOrdered<T> = IObserver<T> & IOrderedObservable;
-export type IOrderedSubscriptionLike<T> = ISubscriptionLike<T> & IOrder;
+export type IOrderedSubscriptionLike<T> = (ISubscriptionLike<T> & IOrder);
 export type IOrderedSubscribe<T> = {
     subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
 };