evg_observable 1.1.32 → 1.2.33

package/package.json

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

package/src/outLib/Collector.js

@@ -16,7 +16,8 @@ class Collector {
         }
     }
     unsubscribe(subscriptionLike) {
-        if (this._isDestroyed) return null;
+        if (this._isDestroyed)
+            return null;
         subscriptionLike && subscriptionLike.unsubscribe();
         FunctionLibs_1.deleteFromArray(this.list, subscriptionLike);
     }

package/src/outLib/Observable.d.ts

@@ -1,8 +1,9 @@
-import { ICallback, IListener, IMarkedForUnsubscribe, IObserver, ISetup, ISubscribe, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { ICallback, IErrorCallback, IListener, IMarkedForUnsubscribe, IObserver, ISetup, ISubscribe, ISubscribeObject, ISubscriptionLike } from "./Types";
 export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedForUnsubscribe {
     isMarkedForUnsubscribe: boolean;
     protected observable: IObserver<T> | undefined;
     protected listener: IListener<T> | undefined;
+    protected errorHandler: IErrorCallback;
     protected _order: number;
     private isListenPaused;
     private once;
@@ -12,9 +13,9 @@ export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedF
     private emitByPositiveCondition;
     private emitMatchCondition;
     protected isPipe: boolean;
-    constructor(observable?: IObserver<T>, listener?: IListener<T>, isPipe?: boolean);
+    constructor(observable?: IObserver<T>, isPipe?: boolean);
     private static callbackSend;
-    subscribe(listener: IListener<T>): ISubscriptionLike<T>;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike<T>;
     unsubscribe(): void;
     send(value: T): void;
     setOnce(): ISubscribe<T>;
@@ -46,7 +47,7 @@ export declare class Observable<T> implements IObserver<T> {
     unsubscribeAll(): void;
     getValue(): T | undefined;
     size(): number;
-    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike<T> | undefined;
     pipe(): ISetup<T> | undefined;
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = exports.SubscribeObject = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
 class SubscribeObject {
-    constructor(observable, listener, isPipe) {
+    constructor(observable, isPipe) {
         this.isMarkedForUnsubscribe = false;
+        this.errorHandler = (errorData, errorMessage) => {
+            console.log(`(Unit of SubscribeObject).send(${errorData}) ERROR:`, errorMessage);
+        };
         this._order = 0;
         this.isListenPaused = false;
         this.once = { isOnce: false, isFinished: false };
@@ -15,7 +18,6 @@ class SubscribeObject {
         this.emitMatchCondition = null;
         this.isPipe = false;
         this.observable = observable;
-        this.listener = listener;
         this.isPipe = !!isPipe;
     }
     static callbackSend(value, subsObj) {
@@ -62,8 +64,9 @@ class SubscribeObject {
                 break;
         }
     }
-    subscribe(listener) {
+    subscribe(listener, errorHandler) {
         this.listener = listener;
+        errorHandler && (this.errorHandler = errorHandler);
         return this;
     }
     unsubscribe() {
@@ -78,7 +81,7 @@ class SubscribeObject {
             SubscribeObject.callbackSend(value, this);
         }
         catch (err) {
-            console.log('(Unit of SubscribeObject).send(value: T) ERROR:', err);
+            this.errorHandler(value, err);
         }
     }
     setOnce() {
@@ -110,9 +113,9 @@ class SubscribeObject {
         return this;
     }
     emitMatch(condition) {
-        if (typeof condition !== "function")
-            condition =
-                () => `ERROR CONDITION TYPE ${typeof condition},  CONTROL STATE ${this.observable && !this.observable.getValue()}`;
+        if (typeof condition !== "function") {
+            condition = () => `ERROR CONDITION TYPE ${typeof condition},  CONTROL STATE ${this.observable && !this.observable.getValue()}`;
+        }
         this.emitMatchCondition = condition;
         return this;
     }
@@ -157,8 +160,7 @@ class Observable {
         this.isNextProcess = true;
         const length = this.listeners.length;
         for (let i = 0; i < length; i++) {
-            const listener = this.listeners[i];
-            listener.send(value);
+            this.listeners[i].send(value);
         }
         this.isNextProcess = false;
         this.listenersForUnsubscribe.length && this.handleListenersForUnsubscribe();
@@ -174,7 +176,7 @@ 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;
@@ -191,12 +193,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)
@@ -208,19 +205,20 @@ class Observable {
             return 0;
         return this.listeners.length;
     }
-    subscribe(listener) {
+    subscribe(listener, errorHandler) {
         if (this._isDestroyed)
             return undefined;
         if (!listener)
             return undefined;
-        const subscribeObject = new SubscribeObject(this, listener, false);
+        const subscribeObject = new SubscribeObject(this, false);
+        subscribeObject.subscribe(listener, errorHandler);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new SubscribeObject(this, undefined, true);
+        const subscribeObject = new SubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }

package/src/outLib/OrderedObservable.d.ts

@@ -1,10 +1,10 @@
 import { Observable, SubscribeObject } from "./Observable";
-import { ICallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike } from "./Types";
+import { ICallback, IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike } from "./Types";
 export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> {
-    constructor(observable: OrderedObservable<T> | IOrdered<T>, listener?: IListener<T>, isPipe?: boolean);
+    constructor(observable: OrderedObservable<T> | IOrdered<T>, isPipe?: boolean);
     get order(): number;
     set order(value: number);
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike<T>;
     setOnce(): IOrderedSubscribe<T>;
     unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
     unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<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;
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T> | undefined;
+    sortByOrder(): boolean;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): 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, isPipe) {
-        super(observable, listener, isPipe);
+    constructor(observable, isPipe) {
+        super(observable, isPipe);
     }
     get order() {
         return this._order;
@@ -18,8 +18,9 @@ class OrderedSubscribeObject extends Observable_1.SubscribeObject {
         this._order = value;
         this.observable.sortByOrder();
     }
-    subscribe(listener) {
+    subscribe(listener, errorHandler) {
         this.listener = listener;
+        errorHandler && (this.errorHandler = errorHandler);
         return this;
     }
     setOnce() {
@@ -45,7 +46,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 +54,22 @@ class OrderedObservable extends Observable_1.Observable {
                 return -1;
             return 0;
         });
+        return true;
     }
-    subscribe(listener) {
+    subscribe(listener, errorHandler) {
         if (this._isDestroyed)
             return undefined;
         if (!listener)
             return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, listener, false);
+        const subscribeObject = new OrderedSubscribeObject(this, false);
+        subscribeObject.subscribe(listener, errorHandler);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, undefined, true);
+        const subscribeObject = new OrderedSubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }

package/src/outLib/Types.d.ts

@@ -2,8 +2,9 @@ export type ICallback<T> = (value?: T) => any;
 export type IMarkedForUnsubscribe = {
     isMarkedForUnsubscribe: boolean;
 };
+export type IErrorCallback = (errorData: any, errorMessage: any) => void;
 export type ISubscribe<T> = {
-    subscribe(listener: IListener<T>): ISubscriptionLike<T> | undefined;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike<T> | undefined;
 };
 export type IListener<T> = ICallback<T>;
 export type IDestroy = {
@@ -91,12 +92,12 @@ 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);
 export type IOrderedSubscribe<T> = {
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike<T>;
 };
 export type IGroup = ICollector & {
     name: string;