evg_observable 1.1.24 → 1.1.26

package/README.md

@@ -19,18 +19,6 @@ EVG Observable - is a small library for serving asynchronous events.
 
 # Usage
 
-### tsconfig.json
-
-recommended value of the "strict" field in the configuration
-
-```json
-{
-  "compilerOptions": {
-    "strict": false
-  }
-}
-```
-
 ## Observable simple usage
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.1.24",
+  "version": "1.1.26",
   "description": "Light observable",
   "main": "index.js",
   "directories": {
@@ -22,13 +22,13 @@
   },
   "homepage": "https://github.com/BarushevEA/light-observable-ts#readme",
   "devDependencies": {
-    "typescript": "^4.5.5",
-    "@testdeck/mocha": "^0.2.0",
-    "@types/chai": "^4.3.0",
-    "chai": "^4.3.6",
-    "mocha": "^9.2.0",
+    "typescript": "^4.9.4",
+    "@testdeck/mocha": "^0.3.3",
+    "@types/chai": "^4.3.4",
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0",
     "nyc": "^15.1.0",
-    "ts-node": "^10.4.0"
+    "ts-node": "^10.9.1"
   },
   "keywords": [
     "EVG Observable",

package/src/outLib/Collector.d.ts

@@ -2,9 +2,9 @@ import { ICollector, ISubscriptionLike } from "./Types";
 export declare class Collector implements ICollector {
     protected list: ISubscriptionLike<any>[];
     private _isDestroyed;
-    collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void;
-    unsubscribe(subscriptionLike: ISubscriptionLike<any>): void;
-    unsubscribeAll(): void;
+    collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void | null;
+    unsubscribe(subscriptionLike: ISubscriptionLike<any> | undefined): void | null;
+    unsubscribeAll(): void | null;
     size(): number;
     destroy(): void;
     get isDestroyed(): boolean;

package/src/outLib/Observable.d.ts

@@ -1,7 +1,7 @@
 import { ICallback, IListener, IObserver, ISetup, ISubscribe, ISubscribeObject, ISubscriptionLike } from "./Types";
 export declare class SubscribeObject<T> implements ISubscribeObject<T> {
-    protected observable: IObserver<T>;
-    protected listener: IListener<T>;
+    protected observable: IObserver<T> | undefined;
+    protected listener: IListener<T> | undefined;
     private isListenPaused;
     private once;
     private unsubscribeByNegativeCondition;
@@ -42,9 +42,9 @@ export declare class Observable<T> implements IObserver<T> {
     unSubscribe(listener: ISubscriptionLike<T>): void;
     destroy(): void;
     unsubscribeAll(): void;
-    getValue(): T;
+    getValue(): T | undefined;
     size(): number;
-    subscribe(listener: IListener<T>): ISubscriptionLike<T>;
-    pipe(): ISetup<T>;
+    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
+    pipe(): ISetup<T> | undefined;
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -30,7 +30,7 @@ class SubscribeObject {
         this.sendValueToListener(value);
     }
     sendValueToListener(value) {
-        const asyncSend = () => {
+        const asyncSend = (value) => {
             const listener = this.listener;
             return new Promise((resolve => {
                 switch (true) {
@@ -42,7 +42,7 @@ class SubscribeObject {
                         return;
                     case this.once.isOnce:
                         this.once.isFinished = true;
-                        listener((value));
+                        listener && listener((value));
                         this.unsubscribe();
                         break;
                     case !!this.unsubscribeByNegativeCondition:
@@ -51,7 +51,7 @@ class SubscribeObject {
                             this.unsubscribe();
                             return;
                         }
-                        listener((value));
+                        listener && listener((value));
                         break;
                     case !!this.unsubscribeByPositiveCondition:
                         if (this.unsubscribeByPositiveCondition()) {
@@ -59,24 +59,24 @@ class SubscribeObject {
                             this.unsubscribe();
                             return;
                         }
-                        listener((value));
+                        listener && listener((value));
                         break;
                     case !!this.emitByNegativeCondition:
-                        !this.emitByNegativeCondition() && listener(value);
+                        !this.emitByNegativeCondition() && listener && listener(value);
                         break;
                     case !!this.emitByPositiveCondition:
-                        this.emitByPositiveCondition() && listener(value);
+                        this.emitByPositiveCondition() && listener && listener(value);
                         break;
                     case !!this.emitMatchCondition:
-                        (this.emitMatchCondition() === value) && listener(value);
+                        (this.emitMatchCondition() === value) && listener && listener(value);
                         break;
                     default:
-                        listener((value));
+                        listener && listener((value));
                 }
                 resolve(true);
             }));
         };
-        asyncSend()
+        asyncSend(value)
             .catch(err => {
             console.log('(Unit of SubscribeObject).send(value: T) call .sendValueToListener(value: T) ERROR:', err);
         });
@@ -111,7 +111,8 @@ class SubscribeObject {
     }
     emitMatch(condition) {
         if (typeof condition !== "function")
-            condition = () => `ERROR CONDITION TYPE ${typeof condition},  CONTROL STATE ${!this.observable.getValue()}`;
+            condition =
+                () => `ERROR CONDITION TYPE ${typeof condition},  CONTROL STATE ${this.observable && !this.observable.getValue()}`;
         this.emitMatchCondition = condition;
         return this;
     }
@@ -184,9 +185,12 @@ class Observable {
     unsubscribeAll() {
         if (this._isDestroyed)
             return;
-        const length = this.listeners.length;
-        for (let i = 0; i < length; i++)
-            (this.listeners.pop()).unsubscribe();
+        const listeners = this.listeners;
+        const length = listeners.length;
+        for (let i = 0; i < length; i++) {
+            const subscriber = listeners.pop();
+            subscriber && subscriber.unsubscribe();
+        }
     }
     getValue() {
         if (this._isDestroyed)

package/src/outLib/OrderedObservable.d.ts

@@ -1,5 +1,5 @@
 import { Observable, SubscribeObject } from "./Observable";
-import { ICallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike } from "./Types";
+import { ICallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISubscriptionLike } 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>): IOrderedSubscriptionLike<T>;
-    pipe(): IOrderedSetup<T>;
+    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
+    pipe(): IOrderedSetup<T> | undefined;
 }

package/src/outLib/Types.d.ts

@@ -1,101 +1,101 @@
-export declare type ICallback<T> = (value?: T) => any;
-export declare type ISubscribe<T> = {
-    subscribe(listener: IListener<T>): ISubscriptionLike<T>;
+export type ICallback<T> = (value?: T) => any;
+export type ISubscribe<T> = {
+    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
 };
-export declare type IListener<T> = ICallback<T>;
-export declare type IDestroy = {
+export type IListener<T> = ICallback<T>;
+export type IDestroy = {
     destroy(): void;
     isDestroyed: boolean;
 };
-export declare type IOnceMarker = {
+export type IOnceMarker = {
     isOnce: boolean;
     isFinished: boolean;
 };
-export declare type IOrder = {
+export type IOrder = {
     order: number;
 };
-export declare type IOnce<T> = {
+export type IOnce<T> = {
     setOnce(): ISubscribe<T>;
 };
-export declare type IOrderedOnce<T> = {
+export type IOrderedOnce<T> = {
     setOnce(): IOrderedSubscribe<T>;
 };
-export declare type ISetObservableValue = {
+export type ISetObservableValue = {
     next(value: any): void;
 };
-export declare type ISubscriptionLike<T> = {
+export type ISubscriptionLike<T> = {
     unsubscribe(): void;
 };
-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>;
-export declare type ISubscribeCounter = {
+export type ISetup<T> = IUnsubscribeByNegative<T> & IUnsubscribeByPositive<T> & IEmitByNegative<T> & IEmitByPositive<T> & IEmitMatchCondition<T> & IOnce<T> & ISubscribe<T>;
+export type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSubscribe<T>;
+export type ISubscribeObject<T> = ISubscriptionLike<T> & IPause & IOrder & ISend<T> & ISetup<T>;
+export type ISubscribeCounter = {
     size(): number;
 };
-export declare type ISubscriber<T> = {
-    getValue(): T;
+export type ISubscriber<T> = {
+    getValue(): T | undefined;
     isEnable: boolean;
 } & ISubscribe<T>;
-export declare type IObserver<T> = ISetObservableValue & ISubscriber<T> & IDestroy & ISubscribeCounter & IObservablePipe<T> & {
-    unSubscribe(ISubscriptionLike: any): void;
+export type IObserver<T> = ISetObservableValue & ISubscriber<T> & IDestroy & ISubscribeCounter & IObservablePipe<T> & {
+    unSubscribe(subscriber: ISubscriptionLike<T>): void;
     unsubscribeAll(): void;
     disable(): void;
     enable(): void;
 };
-export declare type IPause = {
+export type IPause = {
     pause(): void;
     resume(): void;
 };
-export declare type IObservablePipe<T> = {
-    pipe(): ISetup<T>;
+export type IObservablePipe<T> = {
+    pipe(): ISetup<T> | undefined;
 };
-export declare type ISend<T> = {
+export type ISend<T> = {
     send(value: T): void;
 };
-export declare type IUnsubscribeByNegative<T> = {
+export type IUnsubscribeByNegative<T> = {
     unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
 };
-export declare type IOrderedUnsubscribeByNegative<T> = {
+export type IOrderedUnsubscribeByNegative<T> = {
     unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
 };
-export declare type IUnsubscribeByPositive<T> = {
+export type IUnsubscribeByPositive<T> = {
     unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;
 };
-export declare type IOrderedUnsubscribeByPositive<T> = {
+export type IOrderedUnsubscribeByPositive<T> = {
     unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
 };
-export declare type IEmitByNegative<T> = {
+export type IEmitByNegative<T> = {
     emitByNegative(condition: ICallback<any>): ISubscribe<T>;
 };
-export declare type IOrderedEmitByNegative<T> = {
+export type IOrderedEmitByNegative<T> = {
     emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
 };
-export declare type IEmitByPositive<T> = {
+export type IEmitByPositive<T> = {
     emitByPositive(condition: ICallback<any>): ISubscribe<T>;
 };
-export declare type IOrderedEmitByPositive<T> = {
+export type IOrderedEmitByPositive<T> = {
     emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
 };
-export declare type IEmitMatchCondition<T> = {
+export type IEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): ISubscribe<T>;
 };
-export declare type IOrderedEmitMatchCondition<T> = {
+export type IOrderedEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
 };
-export declare type ICollector = IDestroy & ISubscribeCounter & {
+export type ICollector = IDestroy & ISubscribeCounter & {
     collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void;
     unsubscribe(subscriptionLike: ISubscriptionLike<any>): void;
     unsubscribeAll(): void;
 };
-export declare type IOrderedObservable = {
+export type IOrderedObservable = {
     sortByOrder(): void;
 };
-export declare type IOrdered<T> = IObserver<T> & IOrderedObservable;
-export declare type IOrderedSubscriptionLike<T> = ISubscriptionLike<T> & IOrder;
-export declare type IOrderedSubscribe<T> = {
+export type IOrdered<T> = IObserver<T> & IOrderedObservable;
+export type IOrderedSubscriptionLike<T> = ISubscriptionLike<T> & IOrder;
+export type IOrderedSubscribe<T> = {
     subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
 };
-export declare type IGroup = ICollector & {
+export type IGroup = ICollector & {
     name: string;
     order: number;
 };