evg_observable 1.5.39 → 1.5.41

package/README.md

@@ -8,7 +8,7 @@ EVG Observable - is a light library for simple use.
 
 ## What is EVG Observable?
 
-EVG Observable is a compact, lightweight library designed for handling asynchronous events. Despite its small size, it offers over 20 powerful techniques for event management. Despite this, it provides over 20 different ways of event handling.
+EVG Observable is a compact, lightweight library designed for handling asynchronous events. Despite its small size, it offers over 20 powerful techniques for event management.
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.5.39",
+  "version": "1.5.41",
   "description": "Alternative fast and light library version - observable.",
   "directories": {
     "test": "test"

package/src/outLib/FunctionLibs.d.ts

@@ -2,3 +2,4 @@ export declare function deleteFromArray<T>(arr: T[], component: T): boolean;
 export declare function quickDeleteFromArray<T>(arr: T[], component: T): boolean;
 export declare const negativeCallback: () => boolean;
 export declare const positiveCallback: () => boolean;
+export declare const randomCallback: () => string;

package/src/outLib/FunctionLibs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.positiveCallback = exports.negativeCallback = exports.quickDeleteFromArray = exports.deleteFromArray = void 0;
+exports.randomCallback = exports.positiveCallback = exports.negativeCallback = exports.quickDeleteFromArray = exports.deleteFromArray = void 0;
 function deleteFromArray(arr, component) {
     const index = arr.indexOf(component);
     if (index === -1)
@@ -22,3 +22,5 @@ const negativeCallback = () => false;
 exports.negativeCallback = negativeCallback;
 const positiveCallback = () => true;
 exports.positiveCallback = positiveCallback;
+const randomCallback = () => "772716b8-e6e2-47ac-95e9-e8d99ce35124";
+exports.randomCallback = randomCallback;

package/src/outLib/Observable.js

@@ -22,50 +22,39 @@ class SubscribeObject {
     }
     static callbackSend(value, subsObj) {
         const listener = subsObj.listener;
-        if (!listener) {
-            subsObj.unsubscribe();
+        if (!listener)
+            return subsObj.unsubscribe();
+        if (!subsObj.observable)
+            return subsObj.unsubscribe();
+        if (subsObj.isListenPaused)
             return;
+        if (!subsObj.isPipe)
+            return listener(value);
+        if (subsObj.emitByPositiveCondition && subsObj.emitByPositiveCondition(value))
+            return listener(value);
+        if (subsObj.emitByNegativeCondition && !subsObj.emitByNegativeCondition(value))
+            return listener(value);
+        if (subsObj.once.isOnce) {
+            subsObj.once.isFinished = true;
+            listener(value);
+            return subsObj.unsubscribe();
+        }
+        if (subsObj.unsubscribeByNegativeCondition) {
+            if (!subsObj.unsubscribeByNegativeCondition(value)) {
+                subsObj.unsubscribeByNegativeCondition = null;
+                return subsObj.unsubscribe();
+            }
+            return listener(value);
         }
-        switch (true) {
-            case !subsObj.observable:
-                subsObj.unsubscribe();
-                return;
-            case subsObj.isListenPaused:
-                return;
-            case !subsObj.isPipe:
-                listener(value);
-                return;
-            case subsObj.once.isOnce:
-                subsObj.once.isFinished = true;
-                listener(value);
-                subsObj.unsubscribe();
-                break;
-            case !!subsObj.unsubscribeByNegativeCondition:
-                if (!subsObj.unsubscribeByNegativeCondition(value)) {
-                    subsObj.unsubscribeByNegativeCondition = null;
-                    subsObj.unsubscribe();
-                    return;
-                }
-                listener(value);
-                break;
-            case !!subsObj.unsubscribeByPositiveCondition:
-                if (subsObj.unsubscribeByPositiveCondition(value)) {
-                    subsObj.unsubscribeByPositiveCondition = null;
-                    subsObj.unsubscribe();
-                    return;
-                }
-                listener(value);
-                break;
-            case !!subsObj.emitByNegativeCondition:
-                !subsObj.emitByNegativeCondition(value) && listener(value);
-                break;
-            case !!subsObj.emitByPositiveCondition:
-                subsObj.emitByPositiveCondition(value) && listener(value);
-                break;
-            case !!subsObj.emitMatchCondition:
-                (subsObj.emitMatchCondition(value) === value) && listener(value);
-                break;
+        if (subsObj.unsubscribeByPositiveCondition) {
+            if (subsObj.unsubscribeByPositiveCondition(value)) {
+                subsObj.unsubscribeByPositiveCondition = null;
+                return subsObj.unsubscribe();
+            }
+            return listener(value);
         }
+        if (subsObj.emitMatchCondition && (subsObj.emitMatchCondition(value) === value))
+            return listener(value);
     }
     subscribe(listener, errorHandler) {
         this.listener = listener;
@@ -73,11 +62,11 @@ class SubscribeObject {
         return this;
     }
     unsubscribe() {
-        if (this.observable) {
-            this.observable.unSubscribe(this);
-            this.observable = 0;
-            this.listener = 0;
-        }
+        if (!this.observable)
+            return;
+        this.observable.unSubscribe(this);
+        this.observable = 0;
+        this.listener = 0;
     }
     send(value) {
         try {
@@ -108,11 +97,7 @@ class SubscribeObject {
         return this;
     }
     emitMatch(condition) {
-        const type = typeof condition;
-        if (type !== "function") {
-            condition = () => `ERROR CONDITION TYPE ${type},  CONTROL STATE ${this.observable && !this.observable.getValue()}`;
-        }
-        this.emitMatchCondition = condition;
+        this.emitMatchCondition = !!condition ? condition : FunctionLibs_1.randomCallback;
         return this;
     }
     resume() {
@@ -154,10 +139,8 @@ class Observable {
             return;
         this.isNextProcess = true;
         this.value = value;
-        const length = this.listeners.length;
-        for (let i = 0; i < length; i++) {
+        for (let i = 0; i < this.listeners.length; i++)
             this.listeners[i].send(value);
-        }
         this.isNextProcess = false;
         this.listenersForUnsubscribe.length && this.handleListenersForUnsubscribe();
     }
@@ -166,16 +149,13 @@ class Observable {
             return;
         if (!this._isEnable)
             return;
-        for (let i = 0; i < values.length; i++) {
+        for (let i = 0; i < values.length; i++)
             this.next(values[i]);
-        }
     }
     handleListenersForUnsubscribe() {
         const length = this.listenersForUnsubscribe.length;
-        for (let i = 0; i < length; i++) {
-            const listener = this.listenersForUnsubscribe[i];
-            this.unSubscribe(listener);
-        }
+        for (let i = 0; i < length; i++)
+            this.unSubscribe(this.listenersForUnsubscribe[i]);
         this.listenersForUnsubscribe.length = 0;
     }
     unSubscribe(listener) {