evg_observable 1.7.45 → 1.9.45

package/package.json

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

package/repo/evg_observable.js

@@ -1 +1 @@
-(()=>{"use strict";const s=(s,e)=>s.order>e.order?1:s.order<e.order?-1:0,e=(s,e)=>s.order>e.order?-1:s.order<e.order?1:0;function i(s,e){const i=s.indexOf(e);return-1!==i&&(s[i]=s[s.length-1],s.length=s.length-1,!0)}class t{constructor(){this.chainHandlers=[],this.pipeData={isBreakChain:!1,isNeedUnsubscribe:!1,isAvailable:!1,payload:null}}setOnce(){const s=this.pipeData;return this.chainHandlers.push((()=>{this.listener(s.payload),s.isNeedUnsubscribe=!0})),this}unsubscribeByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)||(e.isNeedUnsubscribe=!0)})),this}unsubscribeByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)&&(e.isNeedUnsubscribe=!0)})),this}emitByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)||(e.isAvailable=!0)})),this}emitByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)&&(e.isAvailable=!0)})),this}emitMatch(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)==e.payload&&(e.isAvailable=!0)})),this}switch(){return new r(this)}}class r{constructor(s){this.pipe=s,this.caseCounter=s.chainHandlers.length?s.chainHandlers.length:0}subscribe(s,e){return this.pipe.subscribe(s,e)}case(s){this.caseCounter++;const e=this.caseCounter,i=this.pipe.pipeData,t=this.pipe.chainHandlers;return t.push((()=>{i.isAvailable=!0,s(i.payload)&&(i.isBreakChain=!0),e!==t.length||i.isBreakChain||(i.isAvailable=!1)})),this}}class n extends t{constructor(s,e){super(),this.isMarkedForUnsubscribe=!1,this.errorHandler=(s,e)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,e)},this._order=0,this.isPaused=!1,this.isPipe=!1,this.observable=s,this.isPipe=!!e}subscribe(s,e){var i;return this.listener="next"in(i=s)?s=>i.next(s):i,e&&(this.errorHandler=e),this}unsubscribe(){this.observable&&(this.observable.unSubscribe(this),this.observable=null,this.listener=null,this.chainHandlers.length=0)}send(s){try{this.pipeData.payload=s,this.pipeData.isBreakChain=!1,function(s,e){const i=e.listener;if(!i)return e.unsubscribe();if(!e.observable)return e.unsubscribe();if(!e.isPaused){if(!e.isPipe)return i(s);for(let s=0;s<e.chainHandlers.length;s++){if(e.pipeData.isNeedUnsubscribe=!1,e.pipeData.isAvailable=!1,e.chainHandlers[s](),e.pipeData.isNeedUnsubscribe)return e.unsubscribe();if(!e.pipeData.isAvailable)return;if(e.pipeData.isBreakChain)break}i(e.pipeData.payload)}}(s,this)}catch(e){this.errorHandler(s,e)}}resume(){this.isPaused=!1}pause(){this.isPaused=!0}get order(){return this._order}set order(s){this._order=s}}class h{constructor(s){this.value=s,this.listeners=[],this._isEnable=!0,this._isDestroyed=!1,this.isNextProcess=!1,this.listenersForUnsubscribe=[]}disable(){this._isEnable=!1}enable(){this._isEnable=!0}get isEnable(){return this._isEnable}next(s){if(!this._isDestroyed&&this._isEnable){this.isNextProcess=!0,this.value=s;for(let e=0;e<this.listeners.length;e++)this.listeners[e].send(s);this.isNextProcess=!1,this.listenersForUnsubscribe.length&&this.handleListenersForUnsubscribe()}}stream(s){if(!this._isDestroyed&&this._isEnable)for(let e=0;e<s.length;e++)this.next(s[e])}handleListenersForUnsubscribe(){const s=this.listenersForUnsubscribe.length;for(let e=0;e<s;e++)this.unSubscribe(this.listenersForUnsubscribe[e]);this.listenersForUnsubscribe.length=0}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&i(this.listeners,s)}}destroy(){this.value=null,this.unsubscribeAll(),this.listeners=null,this._isDestroyed=!0}unsubscribeAll(){this._isDestroyed||(this.listeners.length=0)}getValue(){if(!this._isDestroyed)return this.value}size(){return this._isDestroyed?0:this.listeners.length}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new n(this,!1);return this.addObserver(i,s,e),i}addObserver(s,e,i){s.subscribe(e,i),this.listeners.push(s)}isSubsValid(s){return!this._isDestroyed&&!!s}pipe(){if(this._isDestroyed)return;const s=new n(this,!0);return this.listeners.push(s),s}get isDestroyed(){return this._isDestroyed}}class a extends n{constructor(s,e){super(s,e)}get order(){return this._order}set order(s){!this.observable||this.observable&&this.observable.isDestroyed?this._order=void 0:(this._order=s,this.observable.sortByOrder())}subscribe(s,e){return super.subscribe(s,e),this}setOnce(){return super.setOnce()}unsubscribeByNegative(s){return super.unsubscribeByNegative(s)}unsubscribeByPositive(s){return super.unsubscribeByPositive(s)}emitByNegative(s){return super.emitByNegative(s)}emitByPositive(s){return super.emitByPositive(s)}emitMatch(s){return super.emitMatch(s)}}const u=window;u.Observable=h,u.Collector=class{constructor(){this.list=[],this._isDestroyed=!1}collect(...s){this._isDestroyed||this.list.push(...s)}unsubscribe(s){this._isDestroyed||(s?.unsubscribe(),i(this.list,s))}unsubscribeAll(){if(!this._isDestroyed)for(;this.list.length>0;)this.unsubscribe(this.list.pop())}size(){return this._isDestroyed?0:this.list.length}destroy(){this.unsubscribeAll(),this.list.length=0,this.list=0,this._isDestroyed=!0}get isDestroyed(){return this._isDestroyed}},u.OrderedObservable=class extends h{constructor(){super(...arguments),this.sortDirection=s}setAscendingSort(){return this.sortDirection=s,this.sortByOrder()}setDescendingSort(){return this.sortDirection=e,this.sortByOrder()}sortByOrder(){return!this._isDestroyed&&(this.listeners.sort(this.sortDirection),!0)}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new a(this,!1);return this.addObserver(i,s,e),i}pipe(){if(this._isDestroyed)return;const s=new a(this,!0);return this.listeners.push(s),s}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&function(s,e){const i=s.indexOf(e);-1!==i&&s.splice(i,1)}(this.listeners,s)}}}})();
+(()=>{"use strict";const s=(s,e)=>s.order>e.order?1:s.order<e.order?-1:0,e=(s,e)=>s.order>e.order?-1:s.order<e.order?1:0;function i(s,e){const i=s.indexOf(e);return-1!==i&&(s[i]=s[s.length-1],s.length=s.length-1,!0)}function t(s){return"next"in s?e=>s.next(e):s}class r{constructor(){this.chainHandlers=[],this.pipeData={isBreakChain:!1,isNeedUnsubscribe:!1,isAvailable:!1,payload:null}}setOnce(){const s=this.pipeData;return this.chainHandlers.push((()=>{this.listener(s.payload),s.isNeedUnsubscribe=!0})),this}unsubscribeByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)||(e.isNeedUnsubscribe=!0)})),this}unsubscribeByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)&&(e.isNeedUnsubscribe=!0)})),this}emitByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)||(e.isAvailable=!0)})),this}emitByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)&&(e.isAvailable=!0)})),this}emitMatch(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)==e.payload&&(e.isAvailable=!0)})),this}switch(){return new n(this)}processChain(s){const e=this.chainHandlers,i=this.pipeData;for(let s=0;s<e.length;s++){if(i.isNeedUnsubscribe=!1,i.isAvailable=!1,e[s](),i.isNeedUnsubscribe)return this.unsubscribe();if(!i.isAvailable)return;if(i.isBreakChain)break}return s(i.payload)}}class n{constructor(s){this.pipe=s,this.caseCounter=s.chainHandlers.length?s.chainHandlers.length:0}subscribe(s,e){return this.pipe.subscribe(s,e)}case(s){this.caseCounter++;const e=this.caseCounter,i=this.pipe.pipeData,t=this.pipe.chainHandlers;return t.push((()=>{i.isAvailable=!0,s(i.payload)&&(i.isBreakChain=!0),e!==t.length||i.isBreakChain||(i.isAvailable=!1)})),this}}class h extends r{constructor(s,e){super(),this.isMarkedForUnsubscribe=!1,this.errorHandler=(s,e)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,e)},this._order=0,this.isPaused=!1,this.isPipe=!1,this.observable=s,this.isPipe=!!e}subscribe(s,e){return this.listener=function(s){if(Array.isArray(s)){const e=[];for(let i=0;i<s.length;i++)e.push(t(s[i]));return s=>{for(let i=0;i<e.length;i++)e[i](s)}}return t(s)}(s),e&&(this.errorHandler=e),this}unsubscribe(){this.observable&&(this.observable.unSubscribe(this),this.observable=null,this.listener=null,this.chainHandlers.length=0)}send(s){try{this.pipeData.payload=s,this.pipeData.isBreakChain=!1,this.processValue(s)}catch(e){this.errorHandler(s,e)}}resume(){this.isPaused=!1}pause(){this.isPaused=!0}get order(){return this._order}set order(s){this._order=s}processValue(s){const e=this.listener;return e&&this.observable?this.isPaused?void 0:this.isPipe?this.processChain(e):e(s):this.unsubscribe()}}class a{constructor(){this.chainHandlers=[],this.pipeData={isBreakChain:!1,isAvailable:!1,payload:null}}get isEmpty(){return 0===this.chainHandlers.length}filter(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)&&(e.isAvailable=!0)})),this}switch(){return new l(this)}processChain(s){const e=this.chainHandlers,i=this.pipeData,t={isOK:!1,payload:void 0};i.payload=s,i.isBreakChain=!1;try{for(let s=0;s<e.length;s++){if(i.isAvailable=!1,e[s](),!i.isAvailable)return t;if(i.isBreakChain)break}}catch(s){return this.errorHandler?this.errorHandler(s,"Filter.processChain ERROR:"):console.log("Filter.processChain ERROR:",s),t}return t.isOK=!0,t.payload=i.payload,t}addErrorHandler(s){this.errorHandler=s}}class l{constructor(s){this.pipe=s,this.caseCounter=s.chainHandlers.length?s.chainHandlers.length:0}case(s){this.caseCounter++;const e=this.caseCounter,i=this.pipe.pipeData,t=this.pipe.chainHandlers;return t.push((()=>{i.isAvailable=!0,s(i.payload)&&(i.isBreakChain=!0),e!==t.length||i.isBreakChain||(i.isAvailable=!1)})),this}}class o{constructor(s){this.value=s,this.listeners=[],this._isEnable=!0,this._isDestroyed=!1,this.isNextProcess=!1,this.listenersForUnsubscribe=[],this.filterCase=new a}addFilter(s){return s&&this.filterCase.addErrorHandler(s),this.filterCase}disable(){this._isEnable=!1}enable(){this._isEnable=!0}get isEnable(){return this._isEnable}next(s){if(!this._isDestroyed&&this._isEnable&&(this.filterCase.isEmpty||this.filterCase.processChain(s).isOK)){this.isNextProcess=!0,this.value=s;for(let e=0;e<this.listeners.length;e++)this.listeners[e].send(s);this.isNextProcess=!1,this.listenersForUnsubscribe.length&&this.handleListenersForUnsubscribe()}}stream(s){if(!this._isDestroyed&&this._isEnable)for(let e=0;e<s.length;e++)this.next(s[e])}handleListenersForUnsubscribe(){const s=this.listenersForUnsubscribe.length;for(let e=0;e<s;e++)this.unSubscribe(this.listenersForUnsubscribe[e]);this.listenersForUnsubscribe.length=0}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&i(this.listeners,s)}}destroy(){this.value=null,this.unsubscribeAll(),this.listeners=null,this._isDestroyed=!0}unsubscribeAll(){this._isDestroyed||(this.listeners.length=0)}getValue(){if(!this._isDestroyed)return this.value}size(){return this._isDestroyed?0:this.listeners.length}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new h(this,!1);return this.addObserver(i,s,e),i}addObserver(s,e,i){s.subscribe(e,i),this.listeners.push(s)}isSubsValid(s){return!this._isDestroyed&&!!s}pipe(){if(this._isDestroyed)return;const s=new h(this,!0);return this.listeners.push(s),s}get isDestroyed(){return this._isDestroyed}}class u extends h{constructor(s,e){super(s,e)}get order(){return this._order}set order(s){!this.observable||this.observable&&this.observable.isDestroyed?this._order=void 0:(this._order=s,this.observable.sortByOrder())}subscribe(s,e){return super.subscribe(s,e),this}setOnce(){return super.setOnce()}unsubscribeByNegative(s){return super.unsubscribeByNegative(s)}unsubscribeByPositive(s){return super.unsubscribeByPositive(s)}emitByNegative(s){return super.emitByNegative(s)}emitByPositive(s){return super.emitByPositive(s)}emitMatch(s){return super.emitMatch(s)}}const c=window;c.Observable=o,c.Collector=class{constructor(){this.list=[],this._isDestroyed=!1}collect(...s){this._isDestroyed||this.list.push(...s)}unsubscribe(s){this._isDestroyed||(s?.unsubscribe(),i(this.list,s))}unsubscribeAll(){if(!this._isDestroyed)for(;this.list.length>0;)this.unsubscribe(this.list.pop())}size(){return this._isDestroyed?0:this.list.length}destroy(){this.unsubscribeAll(),this.list.length=0,this.list=0,this._isDestroyed=!0}get isDestroyed(){return this._isDestroyed}},c.OrderedObservable=class extends o{constructor(){super(...arguments),this.sortDirection=s}setAscendingSort(){return this.sortDirection=s,this.sortByOrder()}setDescendingSort(){return this.sortDirection=e,this.sortByOrder()}sortByOrder(){return!this._isDestroyed&&(this.listeners.sort(this.sortDirection),!0)}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new u(this,!1);return this.addObserver(i,s,e),i}pipe(){if(this._isDestroyed)return;const s=new u(this,!0);return this.listeners.push(s),s}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&function(s,e){const i=s.indexOf(e);-1!==i&&s.splice(i,1)}(this.listeners,s)}}}})();

package/src/outLib/Filter.d.ts

@@ -0,0 +1,17 @@
+import { ICallback, IChainCallback, IErrorCallback, IFilter, IFilterCase, IFilterPayload, IFilterResponse, IFilterSetup, IFilterSwitch } from "./Types";
+export declare class Filter<T> implements IFilter<T>, IFilterSwitch<T> {
+    chainHandlers: IChainCallback[];
+    pipeData: IFilterPayload;
+    private errorHandler;
+    get isEmpty(): boolean;
+    filter(condition: ICallback<any>): IFilterSetup<T>;
+    switch(): FilterSwitchCase<T>;
+    processChain(value: T): IFilterResponse;
+    addErrorHandler(errorHandler: IErrorCallback): void;
+}
+export declare class FilterSwitchCase<T> implements IFilterCase<T> {
+    private pipe;
+    private caseCounter;
+    constructor(pipe: Filter<T>);
+    case(condition: ICallback<any>): IFilterCase<T>;
+}

package/src/outLib/Filter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterSwitchCase = exports.Filter = void 0;
+class Filter {
+    chainHandlers = [];
+    pipeData = { isBreakChain: false, isAvailable: false, payload: null };
+    errorHandler;
+    get isEmpty() {
+        return this.chainHandlers.length === 0;
+    }
+    filter(condition) {
+        const data = this.pipeData;
+        this.chainHandlers.push(() => {
+            if (condition(data.payload))
+                data.isAvailable = true;
+        });
+        return this;
+    }
+    switch() {
+        return new FilterSwitchCase(this);
+    }
+    processChain(value) {
+        const chain = this.chainHandlers;
+        const data = this.pipeData;
+        const response = { isOK: false, payload: undefined };
+        data.payload = value;
+        data.isBreakChain = false;
+        try {
+            for (let i = 0; i < chain.length; i++) {
+                data.isAvailable = false;
+                chain[i]();
+                if (!data.isAvailable)
+                    return response;
+                if (data.isBreakChain)
+                    break;
+            }
+        }
+        catch (err) {
+            if (this.errorHandler) {
+                this.errorHandler(err, "Filter.processChain ERROR:");
+            }
+            else {
+                console.log("Filter.processChain ERROR:", err);
+            }
+            return response;
+        }
+        response.isOK = true;
+        response.payload = data.payload;
+        return response;
+    }
+    addErrorHandler(errorHandler) {
+        this.errorHandler = errorHandler;
+    }
+}
+exports.Filter = Filter;
+class FilterSwitchCase {
+    pipe;
+    caseCounter;
+    constructor(pipe) {
+        this.pipe = pipe;
+        this.caseCounter = pipe.chainHandlers.length ? pipe.chainHandlers.length : 0;
+    }
+    case(condition) {
+        this.caseCounter++;
+        const id = this.caseCounter;
+        const data = this.pipe.pipeData;
+        const chain = this.pipe.chainHandlers;
+        chain.push(() => {
+            data.isAvailable = true;
+            if (condition(data.payload))
+                data.isBreakChain = true;
+            if (id === chain.length && !data.isBreakChain)
+                data.isAvailable = false;
+        });
+        return this;
+    }
+}
+exports.FilterSwitchCase = FilterSwitchCase;

package/src/outLib/FunctionLibs.d.ts

@@ -1,6 +1,6 @@
-import { IListener, ISetObservableValue, ISubscribeObject } from "./Types";
+import { IListener, ISubscribeGroup, ISubscribeObject } from "./Types";
 export declare const sortAscending: (a: ISubscribeObject<any>, b: ISubscribeObject<any>) => 0 | 1 | -1;
 export declare const sortDescending: (a: ISubscribeObject<any>, b: ISubscribeObject<any>) => 0 | 1 | -1;
 export declare function deleteFromArray<T>(arr: T[], component: T): boolean;
 export declare function quickDeleteFromArray<T>(arr: T[], component: T): boolean;
-export declare function getListener<T>(listener: IListener<T> | ISetObservableValue): any;
+export declare function getListener<T>(listener: ISubscribeGroup<T>): IListener<T>;

package/src/outLib/FunctionLibs.js

@@ -35,8 +35,21 @@ function quickDeleteFromArray(arr, component) {
 }
 exports.quickDeleteFromArray = quickDeleteFromArray;
 function getListener(listener) {
+    if (Array.isArray(listener)) {
+        const group = [];
+        for (let i = 0; i < listener.length; i++) {
+            group.push(wrapListener(listener[i]));
+        }
+        return (data) => {
+            for (let i = 0; i < group.length; i++)
+                group[i](data);
+        };
+    }
+    return wrapListener(listener);
+}
+exports.getListener = getListener;
+function wrapListener(listener) {
     if ("next" in listener)
         return (value) => listener.next(value);
     return listener;
 }
-exports.getListener = getListener;

package/src/outLib/Observable.d.ts

@@ -1,13 +1,15 @@
-import { IErrorCallback, IListener, IObserver, ISetObservableValue, ISetup, IStream, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { IAddFilter, IErrorCallback, IFilterSetup, IObserver, ISetup, IStream, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
 import { SubscribeObject } from "./SubscribeObject";
-export declare class Observable<T> implements IObserver<T>, IStream<T> {
+export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilter<T> {
     private value;
     protected listeners: ISubscribeObject<T>[];
     private _isEnable;
     protected _isDestroyed: boolean;
     protected isNextProcess: boolean;
     protected listenersForUnsubscribe: ISubscriptionLike[];
+    private filterCase;
     constructor(value: T);
+    addFilter(errorHandler?: IErrorCallback): IFilterSetup<T>;
     disable(): void;
     enable(): void;
     get isEnable(): boolean;
@@ -19,9 +21,9 @@ export declare class Observable<T> implements IObserver<T>, IStream<T> {
     unsubscribeAll(): void;
     getValue(): T | undefined;
     size(): number;
-    subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
-    protected addObserver(subscribeObject: SubscribeObject<T>, observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): void;
-    protected isSubsValid(listener: IListener<T> | ISetObservableValue): boolean;
+    subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    protected addObserver(subscribeObject: SubscribeObject<T>, observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): void;
+    protected isSubsValid(listener: ISubscribeGroup<T>): boolean;
     pipe(): ISetup<T> | undefined;
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
 const SubscribeObject_1 = require("./SubscribeObject");
+const Filter_1 = require("./Filter");
 class Observable {
     value;
     listeners = [];
@@ -10,9 +11,16 @@ class Observable {
     _isDestroyed = false;
     isNextProcess = false;
     listenersForUnsubscribe = [];
+    filterCase = new Filter_1.Filter();
     constructor(value) {
         this.value = value;
     }
+    addFilter(errorHandler) {
+        if (errorHandler) {
+            this.filterCase.addErrorHandler(errorHandler);
+        }
+        return this.filterCase;
+    }
     disable() {
         this._isEnable = false;
     }
@@ -27,6 +35,10 @@ class Observable {
             return;
         if (!this._isEnable)
             return;
+        if (!this.filterCase.isEmpty) {
+            if (!this.filterCase.processChain(value).isOK)
+                return;
+        }
         this.isNextProcess = true;
         this.value = value;
         for (let i = 0; i < this.listeners.length; i++)

package/src/outLib/OrderedObservable.d.ts

@@ -1,11 +1,11 @@
 import { Observable } from "./Observable";
-import { IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscriptionLike, ISetObservableValue, ISubscriptionLike } from "./Types";
+import { IErrorCallback, IOrdered, IOrderedSetup, IOrderedSubscriptionLike, ISubscribeGroup, ISubscriptionLike } from "./Types";
 export declare class OrderedObservable<T> extends Observable<T> implements IOrdered<T> {
     private sortDirection;
     setAscendingSort(): boolean;
     setDescendingSort(): boolean;
     sortByOrder(): boolean;
-    subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike | undefined;
+    subscribe(listener: ISubscribeGroup<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike | undefined;
     pipe(): IOrderedSetup<T> | undefined;
     unSubscribe(listener: ISubscriptionLike): void;
 }

package/src/outLib/Pipe.d.ts

@@ -10,6 +10,7 @@ export declare abstract class Pipe<T> implements ISubscribe<T> {
     emitByPositive(condition: ICallback<T>): ISetup<T>;
     emitMatch(condition: ICallback<T>): ISetup<T>;
     switch(): SwitchCase<T>;
+    processChain(listener: IListener<T>): void;
 }
 export declare class SwitchCase<T> implements ISubscribe<T>, IPipeCase<T> {
     private pipe;

package/src/outLib/Pipe.js

@@ -57,6 +57,22 @@ class Pipe {
     switch() {
         return new SwitchCase(this);
     }
+    processChain(listener) {
+        const chain = this.chainHandlers;
+        const data = this.pipeData;
+        for (let i = 0; i < chain.length; i++) {
+            data.isNeedUnsubscribe = false;
+            data.isAvailable = false;
+            chain[i]();
+            if (data.isNeedUnsubscribe)
+                return this.unsubscribe();
+            if (!data.isAvailable)
+                return;
+            if (data.isBreakChain)
+                break;
+        }
+        return listener(data.payload);
+    }
 }
 exports.Pipe = Pipe;
 class SwitchCase {

package/src/outLib/SubscribeObject.d.ts

@@ -1,4 +1,4 @@
-import { IErrorCallback, IListener, IMarkedForUnsubscribe, IObserver, ISetObservableValue, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { IErrorCallback, IListener, IMarkedForUnsubscribe, IObserver, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
 import { Pipe } from "./Pipe";
 export declare class SubscribeObject<T> extends Pipe<T> implements ISubscribeObject<T>, IMarkedForUnsubscribe {
     isMarkedForUnsubscribe: boolean;
@@ -9,11 +9,12 @@ export declare class SubscribeObject<T> extends Pipe<T> implements ISubscribeObj
     isPaused: boolean;
     isPipe: boolean;
     constructor(observable?: IObserver<T>, isPipe?: boolean);
-    subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike;
+    subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike;
     unsubscribe(): void;
     send(value: T): void;
     resume(): void;
     pause(): void;
     get order(): number;
     set order(value: number);
+    processValue<T>(value: T): void;
 }

package/src/outLib/SubscribeObject.js

@@ -35,7 +35,7 @@ class SubscribeObject extends Pipe_1.Pipe {
         try {
             this.pipeData.payload = value;
             this.pipeData.isBreakChain = false;
-            processValue(value, this);
+            this.processValue(value);
         }
         catch (err) {
             this.errorHandler(value, err);
@@ -53,28 +53,17 @@ class SubscribeObject extends Pipe_1.Pipe {
     set order(value) {
         this._order = value;
     }
-}
-exports.SubscribeObject = SubscribeObject;
-function processValue(value, subsObj) {
-    const listener = subsObj.listener;
-    if (!listener)
-        return subsObj.unsubscribe();
-    if (!subsObj.observable)
-        return subsObj.unsubscribe();
-    if (subsObj.isPaused)
-        return;
-    if (!subsObj.isPipe)
-        return listener(value);
-    for (let i = 0; i < subsObj.chainHandlers.length; i++) {
-        subsObj.pipeData.isNeedUnsubscribe = false;
-        subsObj.pipeData.isAvailable = false;
-        subsObj.chainHandlers[i]();
-        if (subsObj.pipeData.isNeedUnsubscribe)
-            return subsObj.unsubscribe();
-        if (!subsObj.pipeData.isAvailable)
+    processValue(value) {
+        const listener = this.listener;
+        if (!listener)
+            return this.unsubscribe();
+        if (!this.observable)
+            return this.unsubscribe();
+        if (this.isPaused)
             return;
-        if (subsObj.pipeData.isBreakChain)
-            break;
+        if (!this.isPipe)
+            return listener(value);
+        return this.processChain(listener);
     }
-    return listener(subsObj.pipeData.payload);
 }
+exports.SubscribeObject = SubscribeObject;

package/src/outLib/Types.d.ts

@@ -1,11 +1,12 @@
 import { SwitchCase } from "./Pipe";
+import { FilterSwitchCase } from "./Filter";
 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> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    subscribe(listener: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
 };
 export type IListener<T> = ICallback<T>;
 export type IDestroy = {
@@ -118,3 +119,27 @@ export type IChainCallback = () => void;
 export type IPipeCase<T> = {
     case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
 };
+export type ICombinedSubscriber<T> = IListener<T> | ISetObservableValue;
+export type ISubscribeGroup<T> = ICombinedSubscriber<T> | ICombinedSubscriber<T>[];
+export type IAddFilter<T> = {
+    addFilter(): IFilterSetup<T>;
+};
+export type IFilterSetup<T> = IFilter<T> & IFilterSwitch<T>;
+export type IFilter<T> = {
+    filter(condition: ICallback<any>): IFilterSetup<T>;
+};
+export type IFilterSwitch<T> = {
+    switch(): FilterSwitchCase<T>;
+};
+export type IFilterCase<T> = {
+    case(condition: ICallback<any>): IFilterCase<T>;
+};
+export type IFilterPayload = {
+    isBreakChain: boolean;
+    isAvailable: boolean;
+    payload: any;
+};
+export type IFilterResponse = {
+    isOK: boolean;
+    payload: any;
+};