evg_observable 1.1.19 → 1.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "description": "Light observable",
   "main": "index.js",
   "directories": {
@@ -22,11 +22,11 @@
   },
   "homepage": "https://github.com/BarushevEA/light-observable-ts#readme",
   "devDependencies": {
-    "typescript": "^4.4.2",
+    "typescript": "^4.4.3",
     "@testdeck/mocha": "^0.1.2",
-    "@types/chai": "^4.2.21",
+    "@types/chai": "^4.2.22",
     "chai": "^4.3.4",
-    "mocha": "^9.1.1",
+    "mocha": "^9.1.2",
     "nyc": "^15.1.0",
     "ts-node": "^10.2.1"
   },

package/src/outLib/Observable.d.ts

@@ -9,14 +9,11 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T> {
     private emitByNegativeCondition;
     private emitByPositiveCondition;
     private emitMatchCondition;
-    private isPipePromise;
     protected _order: number;
     constructor(observable?: IObserver<T>, listener?: IListener<T>);
     subscribe(listener: IListener<T>): ISubscriptionLike<T>;
     unsubscribe(): void;
     send(value: T): void;
-    private handlePromiseExecution;
-    private handleNoPromiseExecution;
     setOnce(): ISubscribe<T>;
     unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
     unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;
@@ -27,7 +24,6 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T> {
     pause(): void;
     get order(): number;
     set order(value: number);
-    likePromise(): ISetup<T>;
 }
 export declare class Observable<T> implements IObserver<T> {
     private value;

package/src/outLib/Observable.js

@@ -11,7 +11,6 @@ class SubscribeObject {
         this.emitByNegativeCondition = null;
         this.emitByPositiveCondition = null;
         this.emitMatchCondition = null;
-        this.isPipePromise = false;
         this._order = 0;
         this.observable = observable;
         this.listener = listener;
@@ -28,60 +27,6 @@ class SubscribeObject {
         }
     }
     send(value) {
-        if (this.isPipePromise) {
-            this.handlePromiseExecution(value)
-                .catch(err => console.log(`ERROR: isPipePromise = "true" SubscribeObject.send(${value})`, err));
-        }
-        this.handleNoPromiseExecution(value);
-    }
-    async handlePromiseExecution(value) {
-        try {
-            switch (true) {
-                case !this.observable:
-                case !this.listener:
-                    this.unsubscribe();
-                    return;
-                case this.isListenPaused:
-                    return;
-                case this.once.isOnce:
-                    this.once.isFinished = true;
-                    this.listener(value);
-                    this.unsubscribe();
-                    break;
-                case !!this.unsubscribeByNegativeCondition:
-                    if (!await this.unsubscribeByNegativeCondition()) {
-                        this.unsubscribeByNegativeCondition = null;
-                        this.unsubscribe();
-                        return;
-                    }
-                    this.listener(value);
-                    break;
-                case !!this.unsubscribeByPositiveCondition:
-                    if (await (this.unsubscribeByPositiveCondition())) {
-                        this.unsubscribeByPositiveCondition = null;
-                        this.unsubscribe();
-                        return;
-                    }
-                    this.listener(value);
-                    break;
-                case !!this.emitByNegativeCondition:
-                    !await this.emitByNegativeCondition() && this.listener(value);
-                    break;
-                case !!this.emitByPositiveCondition:
-                    await this.emitByPositiveCondition() && this.listener(value);
-                    break;
-                case !!this.emitMatchCondition:
-                    (await this.emitMatchCondition() === value) && this.listener(value);
-                    break;
-                default:
-                    this.listener(value);
-            }
-        }
-        catch (err) {
-            console.log(`ERROR: handlePromiseExecution, SubscribeObject.send(${value})`, err);
-        }
-    }
-    handleNoPromiseExecution(value) {
         switch (true) {
             case !this.observable:
             case !this.listener:
@@ -129,31 +74,31 @@ class SubscribeObject {
     }
     unsubscribeByNegative(condition) {
         if (typeof condition !== "function")
-            condition = () => true;
+            condition = () => false;
         this.unsubscribeByNegativeCondition = condition;
         return this;
     }
     unsubscribeByPositive(condition) {
         if (typeof condition !== "function")
-            condition = () => false;
+            condition = () => true;
         this.unsubscribeByPositiveCondition = condition;
         return this;
     }
     emitByNegative(condition) {
         if (typeof condition !== "function")
-            condition = () => false;
+            condition = () => true;
         this.emitByNegativeCondition = condition;
         return this;
     }
     emitByPositive(condition) {
         if (typeof condition !== "function")
-            condition = () => true;
+            condition = () => false;
         this.emitByPositiveCondition = condition;
         return this;
     }
     emitMatch(condition) {
         if (typeof condition !== "function")
-            condition = () => true;
+            condition = () => `ERROR CONDITION TYPE ${typeof condition},  CONTROL STATE ${!this.observable.getValue()}`;
         this.emitMatchCondition = condition;
         return this;
     }
@@ -169,10 +114,6 @@ class SubscribeObject {
     set order(value) {
         this._order = value;
     }
-    likePromise() {
-        this.isPipePromise = true;
-        return this;
-    }
 }
 exports.SubscribeObject = SubscribeObject;
 class Observable {

package/src/outLib/Types.d.ts

@@ -28,7 +28,7 @@ export declare type ISubscriptionLike<T> = {
 };
 export declare type ISetup<T> = IUnsubscribeByNegative<T> & IUnsubscribeByPositive<T> & IEmitByNegative<T> & IEmitByPositive<T> & IEmitMatchCondition<T> & IOnce<T> & ISubscribe<T>;
 export declare type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSubscribe<T>;
-export declare type ISubscribeObject<T> = ISubscriptionLike<T> & IPause & IOrder & ISend<T> & ISetup<T> & IPromise<T>;
+export declare type ISubscribeObject<T> = ISubscriptionLike<T> & IPause & IOrder & ISend<T> & ISetup<T>;
 export declare type ISubscribeCounter = {
     size(): number;
 };
@@ -99,20 +99,3 @@ export declare type IGroup = ICollector & {
     name: string;
     order: number;
 };
-export declare type IGroupManager = IDestroy & ISubscribeCounter & {
-    unsubscribe(subscriptionLike: ISubscriptionLike<any>): void;
-    unsubscribeGroup(name: string): any;
-    unsubscribeAll(): void;
-    addGroup(group: IGroup): any;
-    getGroup(name: any): IGroup;
-};
-export declare type IGroupOptions = {
-    name: string;
-    subscribers?: IOrderedSubscriptionLike<any>[];
-};
-export declare type IPromise<T> = {
-    likePromise(): ISetup<T>;
-};
-export declare type IOrderedPromise<T> = {
-    likePromise(): IOrderedSetup<T>;
-};