evg_observable 1.14.55 → 2.14.56

package/README.md

@@ -216,46 +216,6 @@ observable$.next({message: "some message3", isNeedUnsubscribe: true});
 
 Observable will send a value to the listener only if condition returns "true". There is no automatic unsubscription.
 
-### pipe().emitMatch(condition)
-
-Observable will send a value to the subscriber only if the return value of the condition matches the data being sent. In
-this case, there is no automatic unsubscription.
-
-```ts
-import {Observable} from "evg_observable";
-
-const observable$ = new Observable('Some typed data (not only string)');
-const listener1 = (value: string) => console.log('listener1:', value);
-const listener2 = (value: string) => console.log('listener2:', value);
-const TARGET_DATA = 'TARGET_DATA';
-
-const subscriber1 = observable$
-    .pipe()
-    .emitMatch(() => TARGET_DATA)
-    .subscribe(listener1);
-const subscriber2 = observable$.subscribe(listener2);
-
-console.log(observable$.getValue());
-// Print to console - Some typed data (not only string)
-
-observable$.next('Next1 typed data');
-// Print to console - listener2: Next1 typed data
-
-observable$.next('Next2 typed data');
-// Print to console - listener2: Next2 typed data
-
-observable$.next(TARGET_DATA);
-// Print to console - listener1: TARGET_DATA
-// Print to console - listener2: TARGET_DATA
-
-observable$.next('Next4 typed data');
-// Print to console - listener2: Next4 typed data
-
-observable$.next(TARGET_DATA);
-// Print to console - listener1: TARGET_DATA
-// Print to console - listener2: TARGET_DATA
-```
-
 ### pipe().serialize()
 
 To convert the observable's data to JSON format, you can use the serialize method. This method turns the observer's
@@ -501,8 +461,8 @@ women$.pipe()
 
 // Stream the list of people by applying the age filters
 personal$.pipe()
-    .emitByPositive(youngAgeFilter)
-    .emitByPositive(oldAgeFilter)
+    .refine(youngAgeFilter)
+    .refine(oldAgeFilter)
     .subscribe([men$, women$]);
 
 // Stream the list of people considering the hair color
@@ -614,14 +574,9 @@ observable is set to be a once-off observable to which a listener is subscribed.
 | method                               | will return                            | description                                                                                                                                                                                                             |
 |:-------------------------------------|:---------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `.setOnce()`                         | pipe object                            | observable will send a value to the subscriber only once, and the subscriber will unsubscribe.                                                                                                                          |
-| `.unsubscribeByNegative(*condition)` | pipe object                            | observable will send a value to the subscriber as long as the condition is positive, on the first negative result, the subscriber will unsubscribe                                                                      |
-| `.unsubscribeByPositive(*condition)` | pipe object                            | observable will send a value to the subscriber as long as the condition is negative, on the first positive result, the subscriber will unsubscribe                                                                      |
 | `.unsubscribeBy(*condition)`         | pipe object                            | observable will send a value to the subscriber as long as the condition is negative, on the first positive result, the subscriber will unsubscribe                                                                      |
-| `.emitByNegative(*condition)`        | pipe object                            | observable will send a value to the listener only if condition returns "false", there is no automatic unsubscription                                                                                                    |
-| `.emitByPositive(*condition)`        | pipe object                            | observable will send a value to the listener only if condition returns "true", there is no automatic unsubscription                                                                                                     |
 | `.refine(*condition)`                | pipe object                            | observable will send a value to the listener only if condition returns "true", there is no automatic unsubscription                                                                                                     |
 | `.pushRefiners(*conditions)`         | pipe object                            | This method allows you to add a group of conditions for filtering data in the pipeline chain.                                                                                                                           |
-| `.emitMatch(*condition)`             | pipe object                            | observable will send a value to the subscriber only if the return value of the condition matches the data being sent, in this case, there is no automatic unsubscription                                                |
 | `.switch()`                          | SwitchCase object                      | transitions the pipe into switch-case mode. In this mode, only the first condition that returns a positive result is triggered, and all others are ignored. This allows you to handle multiple cases more conveniently. |
 | `.case(*condition)`                  | PipeCase object                        | Adds a condition to the chain of cases. The entire chain operates on the principle of "OR". This is different from other pipe methods which, when chained, operate on the principle of "AND".                           |
 | `.pushCases(*conditions)`            | PipeCase object                        | This method allows you to add a group of conditions for filtering cases data in the pipeline chain.                                                                                                                     |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.14.55",
+  "version": "2.14.56",
   "description": "Alternative fast and light library version - observable.",
   "main": "src/outLib/index.js",
   "directories": {

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)}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}unsubscribeBy(s){return this.unsubscribeByPositive(s)}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}refine(s){return this.emitByPositive(s)}pushRefiners(s){if(!Array.isArray(s))return this;for(let e=0;e<s.length;e++)this.emitByPositive(s[e]);return 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)}then(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.payload=s(e.payload),e.isAvailable=!0})),this}serialize(){const s=this.pipeData;return this.chainHandlers.push((()=>{s.payload=JSON.stringify(s.payload),s.isAvailable=!0})),this}deserialize(){const s=this.pipeData;return this.chainHandlers.push((()=>{s.payload=JSON.parse(s.payload),s.isAvailable=!0})),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}pushCases(s){if(!Array.isArray(s))return this;for(let e=0;e<s.length;e++)this.case(s[e]);return this}}class h extends r{constructor(s,e){super(),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},this.response={isOK:!1,payload:void 0}}get isEmpty(){return!this.chainHandlers.length}filter(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)&&(e.isAvailable=!0)})),this}pushFilters(s){if(!Array.isArray(s))return this;for(let e=0;e<s.length;e++)this.filter(s[e]);return this}switch(){return new l(this)}processChain(s){const e=this.chainHandlers,i=this.pipeData,t=this.response;t.isOK=!1,t.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}pushCases(s){if(!Array.isArray(s))return this;for(let e=0;e<s.length;e++)this.case(s[e]);return 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){this._isDestroyed||(this.isNextProcess&&s?this.listenersForUnsubscribe.push(s):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){this._isDestroyed||(this.isNextProcess&&s?this.listenersForUnsubscribe.push(s):this.listeners&&function(s,e){const i=s.indexOf(e);-1!==i&&s.splice(i,1)}(this.listeners,s))}}})();
+(()=>{"use strict";const s=(s,i)=>s.order>i.order?1:s.order<i.order?-1:0,i=(s,i)=>s.order>i.order?-1:s.order<i.order?1:0;function e(s,i){const e=s.indexOf(i);return-1!==e&&(s[e]=s[s.length-1],s.length=s.length-1,!0)}function t(s){return"next"in s?i=>s.next(i):s}class r{constructor(s){this.pipe=s,this.counter=s.chain.length?s.chain.length:0}case(s){this.counter++;const i=this.counter,e=this.pipe.chain;return e.push((t=>{t.isAvailable=!0,s(t.payload)&&(t.isBreak=!0),i!==e.length||t.isBreak||(t.isAvailable=!1)})),this}pushCases(s){if(!Array.isArray(s))return this;for(let i=0;i<s.length;i++)this.case(s[i]);return this}}class h{constructor(){this.chain=[],this.flow={isBreak:!1,isUnsubscribe:!1,isAvailable:!1,payload:null}}push(s){return this.chain.push(s),this}setOnce(){return this.push((s=>{this.listener(s.payload),s.isUnsubscribe=!0}))}unsubscribeBy(s){return this.push((i=>{i.isAvailable=!0,s(i.payload)&&(i.isUnsubscribe=!0)}))}refine(s){return this.push((i=>{s(i.payload)&&(i.isAvailable=!0)}))}pushRefiners(s){if(!Array.isArray(s))return this;for(let i=0;i<s.length;i++)this.refine(s[i]);return this}switch(){return new l(this)}then(s){return this.push((i=>{i.payload=s(i.payload),i.isAvailable=!0}))}serialize(){return this.push((s=>{s.payload=JSON.stringify(s.payload),s.isAvailable=!0}))}deserialize(){return this.push((s=>{s.payload=JSON.parse(s.payload),s.isAvailable=!0}))}processChain(s){const i=this.chain,e=this.flow;for(let s=0;s<i.length;s++){if(e.isUnsubscribe=!1,e.isAvailable=!1,i[s](e),e.isUnsubscribe)return this.unsubscribe();if(!e.isAvailable)return;if(e.isBreak)break}return s(e.payload)}}class l extends r{subscribe(s,i){return this.pipe.subscribe(s,i)}}class n extends h{constructor(s,i){super(),this.errorHandler=(s,i)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,i)},this._order=0,this.isPaused=!1,this.isPipe=!1,this.observable=s,this.isPipe=!!i}subscribe(s,i){return this.listener=function(s){if(Array.isArray(s)){const i=[];for(let e=0;e<s.length;e++)i.push(t(s[e]));return s=>{for(let e=0;e<i.length;e++)i[e](s)}}return t(s)}(s),i&&(this.errorHandler=i),this}unsubscribe(){this.observable&&(this.observable.unSubscribe(this),this.observable=null,this.listener=null,this.chain.length=0)}send(s){try{this.flow.payload=s,this.flow.isBreak=!1,this.processValue(s)}catch(i){this.errorHandler(s,i)}}resume(){this.isPaused=!1}pause(){this.isPaused=!0}get order(){return this._order}set order(s){this._order=s}processValue(s){const i=this.listener;return i?this.observable&&!this.isPaused?this.isPipe?this.processChain(i):i(s):void 0:this.unsubscribe()}}class a{constructor(){this.chain=[],this.flow={isBreak:!1,isAvailable:!1,payload:null},this.response={isOK:!1,payload:void 0}}get isEmpty(){return!this.chain.length}push(s){return this.chain.push(s),this}filter(s){return this.push((i=>{s(i.payload)&&(i.isAvailable=!0)}))}pushFilters(s){if(!Array.isArray(s))return this;for(let i=0;i<s.length;i++)this.filter(s[i]);return this}switch(){return new o(this)}processChain(s){const i=this.chain,e=this.flow,t=this.response;t.isOK=!1,t.payload=void 0,e.payload=s,e.isBreak=!1;try{for(let s=0;s<i.length;s++){if(e.isAvailable=!1,i[s](e),!e.isAvailable)return t;if(e.isBreak)break}}catch(s){return this.errHandler?this.errHandler(s,"Filter.processChain ERROR:"):console.log("Filter.processChain ERROR:",s),t}return t.isOK=!0,t.payload=e.payload,t}addErrorHandler(s){this.errHandler=s}}class o extends r{}class u{constructor(s){this.value=s,this.listeners=[],this.isStop=!0,this.isKilled=!1,this.isProcess=!1,this.trash=[],this.filters=new a}addFilter(s){return s&&this.filters.addErrorHandler(s),this.filters}disable(){this.isStop=!1}enable(){this.isStop=!0}get isEnable(){return this.isStop}next(s){if(!this.isKilled&&this.isStop&&(this.filters.isEmpty||this.filters.processChain(s).isOK)){this.isProcess=!0,this.value=s;for(let i=0;i<this.listeners.length;i++)this.listeners[i].send(s);this.isProcess=!1,this.trash.length&&this.handleListenersForUnsubscribe()}}stream(s){if(!this.isKilled&&this.isStop)for(let i=0;i<s.length;i++)this.next(s[i])}handleListenersForUnsubscribe(){const s=this.trash.length;for(let i=0;i<s;i++)this.unSubscribe(this.trash[i]);this.trash.length=0}unSubscribe(s){this.isKilled||(this.isProcess&&s?this.trash.push(s):this.listeners&&e(this.listeners,s))}destroy(){this.value=null,this.unsubscribeAll(),this.listeners=null,this.isKilled=!0}unsubscribeAll(){this.isKilled||(this.listeners.length=0)}getValue(){if(!this.isKilled)return this.value}size(){return this.isKilled?0:this.listeners.length}subscribe(s,i){if(!this.isListener(s))return;const e=new n(this,!1);return this.addObserver(e,s,i),e}addObserver(s,i,e){s.subscribe(i,e),this.listeners.push(s)}isListener(s){return!this.isKilled&&!!s}pipe(){if(this.isKilled)return;const s=new n(this,!0);return this.listeners.push(s),s}get isDestroyed(){return this.isKilled}}class c extends n{constructor(s,i){super(s,i)}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,i){return super.subscribe(s,i),this}setOnce(){return super.setOnce()}}const d=window;d.Observable=u,d.Collector=class{constructor(){this.list=[],this.isKilled=!1}collect(...s){this.isKilled||this.list.push(...s)}unsubscribe(s){this.isKilled||(s?.unsubscribe(),e(this.list,s))}unsubscribeAll(){if(!this.isKilled)for(;this.list.length>0;)this.unsubscribe(this.list.pop())}size(){return this.isKilled?0:this.list.length}destroy(){this.unsubscribeAll(),this.list.length=0,this.list=0,this.isKilled=!0}get isDestroyed(){return this.isKilled}},d.OrderedObservable=class extends u{constructor(){super(...arguments),this.sortDirection=s}setAscendingSort(){return this.sortDirection=s,this.sortByOrder()}setDescendingSort(){return this.sortDirection=i,this.sortByOrder()}sortByOrder(){return!this.isKilled&&(this.listeners.sort(this.sortDirection),!0)}subscribe(s,i){if(!this.isListener(s))return;const e=new c(this,!1);return this.addObserver(e,s,i),e}pipe(){if(this.isKilled)return;const s=new c(this,!0);return this.listeners.push(s),s}unSubscribe(s){this.isKilled||(this.isProcess&&s?this.trash.push(s):this.listeners&&function(s,i){const e=s.indexOf(i);-1!==e&&s.splice(e,1)}(this.listeners,s))}}})();

package/src/outLib/AbstractSwitchCase.d.ts

@@ -0,0 +1,8 @@
+import { ICallback, IChainContainer } from "./Types";
+export declare abstract class SwitchCase<T, P extends IChainContainer, W> {
+    protected pipe: P;
+    protected counter: number;
+    constructor(pipe: P);
+    case(condition: ICallback<any>): W;
+    pushCases(conditions: ICallback<any>[]): W;
+}

package/src/outLib/AbstractSwitchCase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchCase = void 0;
+class SwitchCase {
+    pipe;
+    counter;
+    constructor(pipe) {
+        this.pipe = pipe;
+        this.counter = pipe.chain.length ? pipe.chain.length : 0;
+    }
+    case(condition) {
+        this.counter++;
+        const id = this.counter;
+        const chain = this.pipe.chain;
+        chain.push((data) => {
+            data.isAvailable = true;
+            if (condition(data.payload))
+                data.isBreak = true;
+            if (id === chain.length && !data.isBreak)
+                data.isAvailable = false;
+        });
+        return this;
+    }
+    pushCases(conditions) {
+        if (!Array.isArray(conditions))
+            return this;
+        for (let i = 0; i < conditions.length; i++)
+            this.case(conditions[i]);
+        return this;
+    }
+}
+exports.SwitchCase = SwitchCase;

package/src/outLib/Collector.d.ts

@@ -1,7 +1,7 @@
 import { ICollector, ISubscriptionLike } from "./Types";
 export declare class Collector implements ICollector {
     protected list: ISubscriptionLike[];
-    private _isDestroyed;
+    private isKilled;
     collect(...subscriptionLikeList: ISubscriptionLike[]): void;
     unsubscribe(subscriptionLike: ISubscriptionLike | undefined): void;
     unsubscribeAll(): void | null;

package/src/outLib/Collector.js

@@ -4,25 +4,25 @@ exports.Collector = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
 class Collector {
     list = [];
-    _isDestroyed = false;
+    isKilled = false;
     collect(...subscriptionLikeList) {
-        if (!this._isDestroyed)
+        if (!this.isKilled)
             this.list.push(...subscriptionLikeList);
     }
     unsubscribe(subscriptionLike) {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
         subscriptionLike?.unsubscribe();
         (0, FunctionLibs_1.quickDeleteFromArray)(this.list, subscriptionLike);
     }
     unsubscribeAll() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
         while (this.list.length > 0)
             this.unsubscribe(this.list.pop());
     }
     size() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return 0;
         return this.list.length;
     }
@@ -30,10 +30,10 @@ class Collector {
         this.unsubscribeAll();
         this.list.length = 0;
         this.list = 0;
-        this._isDestroyed = true;
+        this.isKilled = true;
     }
     get isDestroyed() {
-        return this._isDestroyed;
+        return this.isKilled;
     }
 }
 exports.Collector = Collector;

package/src/outLib/FilterCollection.d.ts

@@ -1,20 +1,17 @@
-import { ICallback, IChainCallback, IErrorCallback, IFilter, IFilterCase, IFilterPayload, IFilterResponse, IFilterSetup, IFilterSwitch } from "./Types";
+import { ICallback, IErrorCallback, IFilter, IFilterChainCallback, IFilterPayload, IFilterResponse, IFilterSetup, IFilterSwitch } from "./Types";
+import { SwitchCase } from "./AbstractSwitchCase";
 export declare class FilterCollection<T> implements IFilter<T>, IFilterSwitch<T> {
-    chainHandlers: IChainCallback[];
-    pipeData: IFilterPayload;
+    chain: IFilterChainCallback[];
+    flow: IFilterPayload;
     response: IFilterResponse;
-    private errorHandler;
+    private errHandler;
     get isEmpty(): boolean;
+    private push;
     filter(condition: ICallback<any>): IFilterSetup<T>;
     pushFilters(conditions: 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: FilterCollection<T>);
-    case(condition: ICallback<any>): IFilterCase<T>;
-    pushCases(conditions: ICallback<any>[]): IFilterCase<T>;
+export declare class FilterSwitchCase<T> extends SwitchCase<T, FilterCollection<T>, IFilter<T>> {
 }

package/src/outLib/FilterCollection.js

@@ -1,21 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterSwitchCase = exports.FilterCollection = void 0;
+const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
 class FilterCollection {
-    chainHandlers = [];
-    pipeData = { isBreakChain: false, isAvailable: false, payload: null };
+    chain = [];
+    flow = { isBreak: false, isAvailable: false, payload: null };
     response = { isOK: false, payload: undefined };
-    errorHandler;
+    errHandler;
     get isEmpty() {
-        return !this.chainHandlers.length;
+        return !this.chain.length;
+    }
+    push(callback) {
+        this.chain.push(callback);
+        return this;
     }
     filter(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+        return this.push((data) => {
             if (condition(data.payload))
                 data.isAvailable = true;
         });
-        return this;
     }
     pushFilters(conditions) {
         if (!Array.isArray(conditions))
@@ -28,26 +31,26 @@ class FilterCollection {
         return new FilterSwitchCase(this);
     }
     processChain(value) {
-        const chain = this.chainHandlers;
-        const data = this.pipeData;
+        const chain = this.chain;
+        const data = this.flow;
         const response = this.response;
         response.isOK = false;
         response.payload = undefined;
         data.payload = value;
-        data.isBreakChain = false;
+        data.isBreak = false;
         try {
             for (let i = 0; i < chain.length; i++) {
                 data.isAvailable = false;
-                chain[i]();
+                chain[i](data);
                 if (!data.isAvailable)
                     return response;
-                if (data.isBreakChain)
+                if (data.isBreak)
                     break;
             }
         }
         catch (err) {
-            if (this.errorHandler) {
-                this.errorHandler(err, "Filter.processChain ERROR:");
+            if (this.errHandler) {
+                this.errHandler(err, "Filter.processChain ERROR:");
             }
             else {
                 console.log("Filter.processChain ERROR:", err);
@@ -59,37 +62,10 @@ class FilterCollection {
         return response;
     }
     addErrorHandler(errorHandler) {
-        this.errorHandler = errorHandler;
+        this.errHandler = errorHandler;
     }
 }
 exports.FilterCollection = FilterCollection;
-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;
-    }
-    pushCases(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.case(conditions[i]);
-        return this;
-    }
+class FilterSwitchCase extends AbstractSwitchCase_1.SwitchCase {
 }
 exports.FilterSwitchCase = FilterSwitchCase;

package/src/outLib/Observable.d.ts

@@ -3,11 +3,11 @@ import { SubscribeObject } from "./SubscribeObject";
 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;
+    private isStop;
+    protected isKilled: boolean;
+    protected isProcess: boolean;
+    protected trash: ISubscriptionLike[];
+    private filters;
     constructor(value: T);
     addFilter(errorHandler?: IErrorCallback): IFilterSetup<T>;
     disable(): void;
@@ -23,7 +23,7 @@ export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilt
     size(): number;
     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;
+    protected isListener(listener: ISubscribeGroup<T>): boolean;
     pipe(): ISetup<T> | undefined;
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -7,64 +7,64 @@ const FilterCollection_1 = require("./FilterCollection");
 class Observable {
     value;
     listeners = [];
-    _isEnable = true;
-    _isDestroyed = false;
-    isNextProcess = false;
-    listenersForUnsubscribe = [];
-    filterCase = new FilterCollection_1.FilterCollection();
+    isStop = true;
+    isKilled = false;
+    isProcess = false;
+    trash = [];
+    filters = new FilterCollection_1.FilterCollection();
     constructor(value) {
         this.value = value;
     }
     addFilter(errorHandler) {
         if (errorHandler) {
-            this.filterCase.addErrorHandler(errorHandler);
+            this.filters.addErrorHandler(errorHandler);
         }
-        return this.filterCase;
+        return this.filters;
     }
     disable() {
-        this._isEnable = false;
+        this.isStop = false;
     }
     enable() {
-        this._isEnable = true;
+        this.isStop = true;
     }
     get isEnable() {
-        return this._isEnable;
+        return this.isStop;
     }
     next(value) {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
-        if (!this._isEnable)
+        if (!this.isStop)
             return;
-        if (!this.filterCase.isEmpty) {
-            if (!this.filterCase.processChain(value).isOK)
+        if (!this.filters.isEmpty) {
+            if (!this.filters.processChain(value).isOK)
                 return;
         }
-        this.isNextProcess = true;
+        this.isProcess = true;
         this.value = value;
         for (let i = 0; i < this.listeners.length; i++)
             this.listeners[i].send(value);
-        this.isNextProcess = false;
-        this.listenersForUnsubscribe.length && this.handleListenersForUnsubscribe();
+        this.isProcess = false;
+        this.trash.length && this.handleListenersForUnsubscribe();
     }
     stream(values) {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
-        if (!this._isEnable)
+        if (!this.isStop)
             return;
         for (let i = 0; i < values.length; i++)
             this.next(values[i]);
     }
     handleListenersForUnsubscribe() {
-        const length = this.listenersForUnsubscribe.length;
+        const length = this.trash.length;
         for (let i = 0; i < length; i++)
-            this.unSubscribe(this.listenersForUnsubscribe[i]);
-        this.listenersForUnsubscribe.length = 0;
+            this.unSubscribe(this.trash[i]);
+        this.trash.length = 0;
     }
     unSubscribe(listener) {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
-        if (this.isNextProcess && listener) {
-            this.listenersForUnsubscribe.push(listener);
+        if (this.isProcess && listener) {
+            this.trash.push(listener);
             return;
         }
         this.listeners && !(0, FunctionLibs_1.quickDeleteFromArray)(this.listeners, listener);
@@ -73,25 +73,25 @@ class Observable {
         this.value = null;
         this.unsubscribeAll();
         this.listeners = null;
-        this._isDestroyed = true;
+        this.isKilled = true;
     }
     unsubscribeAll() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
         this.listeners.length = 0;
     }
     getValue() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return undefined;
         return this.value;
     }
     size() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return 0;
         return this.listeners.length;
     }
     subscribe(observer, errorHandler) {
-        if (!this.isSubsValid(observer))
+        if (!this.isListener(observer))
             return undefined;
         const subscribeObject = new SubscribeObject_1.SubscribeObject(this, false);
         this.addObserver(subscribeObject, observer, errorHandler);
@@ -101,20 +101,20 @@ class Observable {
         subscribeObject.subscribe(observer, errorHandler);
         this.listeners.push(subscribeObject);
     }
-    isSubsValid(listener) {
-        if (this._isDestroyed)
+    isListener(listener) {
+        if (this.isKilled)
             return false;
         return !!listener;
     }
     pipe() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return undefined;
         const subscribeObject = new SubscribeObject_1.SubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     get isDestroyed() {
-        return this._isDestroyed;
+        return this.isKilled;
     }
 }
 exports.Observable = Observable;

package/src/outLib/OrderedObservable.js

@@ -15,30 +15,30 @@ class OrderedObservable extends Observable_1.Observable {
         return this.sortByOrder();
     }
     sortByOrder() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return false;
         this.listeners.sort(this.sortDirection);
         return true;
     }
     subscribe(listener, errorHandler) {
-        if (!this.isSubsValid(listener))
+        if (!this.isListener(listener))
             return undefined;
         const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, false);
         this.addObserver(subscribeObject, listener, errorHandler);
         return subscribeObject;
     }
     pipe() {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return undefined;
         const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }
     unSubscribe(listener) {
-        if (this._isDestroyed)
+        if (this.isKilled)
             return;
-        if (this.isNextProcess && listener) {
-            this.listenersForUnsubscribe.push(listener);
+        if (this.isProcess && listener) {
+            this.trash.push(listener);
             return;
         }
         this.listeners && !(0, FunctionLibs_1.deleteFromArray)(this.listeners, listener);

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -1,5 +1,5 @@
 import { SubscribeObject } from "./SubscribeObject";
-import { ICallback, IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISetObservableValue } from "./Types";
+import { IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISetObservableValue } from "./Types";
 import { OrderedObservable } from "./OrderedObservable";
 export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implements IOrderedSetup<T> {
     constructor(observable: OrderedObservable<T> | IOrdered<T>, isPipe?: boolean);
@@ -7,9 +7,4 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implem
     set order(value: number);
     subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
     setOnce(): IOrderedSubscribe<T>;
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSetup<T>;
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSetup<T>;
-    emitByNegative(condition: ICallback<any>): IOrderedSetup<T>;
-    emitByPositive(condition: ICallback<any>): IOrderedSetup<T>;
-    emitMatch(condition: ICallback<any>): IOrderedSetup<T>;
 }

package/src/outLib/OrderedSubscribeObject.js

@@ -25,20 +25,5 @@ class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
     setOnce() {
         return super.setOnce();
     }
-    unsubscribeByNegative(condition) {
-        return super.unsubscribeByNegative(condition);
-    }
-    unsubscribeByPositive(condition) {
-        return super.unsubscribeByPositive(condition);
-    }
-    emitByNegative(condition) {
-        return super.emitByNegative(condition);
-    }
-    emitByPositive(condition) {
-        return super.emitByPositive(condition);
-    }
-    emitMatch(condition) {
-        return super.emitMatch(condition);
-    }
 }
 exports.OrderedSubscribeObject = OrderedSubscribeObject;

package/src/outLib/Pipe.d.ts

@@ -1,28 +1,20 @@
 import { ICallback, IChainCallback, IErrorCallback, IListener, IPipeCase, IPipePayload, ISetObservableValue, ISetup, ISubscribe, ISubscriptionLike } from "./Types";
+import { SwitchCase } from "./AbstractSwitchCase";
 export declare abstract class Pipe<T> implements ISubscribe<T> {
-    chainHandlers: IChainCallback[];
-    pipeData: IPipePayload;
+    chain: IChainCallback[];
+    flow: IPipePayload;
     abstract subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    private push;
     setOnce(): ISubscribe<T>;
-    unsubscribeByNegative(condition: ICallback<T>): ISetup<T>;
-    unsubscribeByPositive(condition: ICallback<T>): ISetup<T>;
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
-    emitByNegative(condition: ICallback<T>): ISetup<T>;
-    emitByPositive(condition: ICallback<T>): ISetup<T>;
     refine(condition: ICallback<T>): ISetup<T>;
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
-    emitMatch(condition: ICallback<T>): ISetup<T>;
-    switch(): SwitchCase<T>;
+    switch(): PipeSwitchCase<T>;
     then<K>(condition: ICallback<T>): ISetup<K>;
     serialize(): ISetup<string>;
     deserialize<K>(): ISetup<K>;
     processChain(listener: IListener<T>): void;
 }
-export declare class SwitchCase<T> implements ISubscribe<T>, IPipeCase<T> {
-    private pipe;
-    private caseCounter;
-    constructor(pipe: Pipe<T>);
+export declare class PipeSwitchCase<T> extends SwitchCase<T, Pipe<T>, IPipeCase<T>> implements ISubscribe<T> {
     subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
-    case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
-    pushCases(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
 }

package/src/outLib/Pipe.js

@@ -1,147 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwitchCase = exports.Pipe = void 0;
+exports.PipeSwitchCase = exports.Pipe = void 0;
+const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
 class Pipe {
-    chainHandlers = [];
-    pipeData = { isBreakChain: false, isNeedUnsubscribe: false, isAvailable: false, payload: null };
-    setOnce() {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
-            this.listener(data.payload);
-            data.isNeedUnsubscribe = true;
-        });
+    chain = [];
+    flow = { isBreak: false, isUnsubscribe: false, isAvailable: false, payload: null };
+    push(callback) {
+        this.chain.push(callback);
         return this;
     }
-    unsubscribeByNegative(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
-            data.isAvailable = true;
-            if (!condition(data.payload))
-                data.isNeedUnsubscribe = true;
+    setOnce() {
+        return this.push((data) => {
+            this.listener(data.payload);
+            data.isUnsubscribe = true;
         });
-        return this;
     }
-    unsubscribeByPositive(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+    unsubscribeBy(condition) {
+        return this.push((data) => {
             data.isAvailable = true;
             if (condition(data.payload))
-                data.isNeedUnsubscribe = true;
+                data.isUnsubscribe = true;
         });
-        return this;
     }
-    unsubscribeBy(condition) {
-        return this.unsubscribeByPositive(condition);
-    }
-    emitByNegative(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
-            if (!condition(data.payload))
-                data.isAvailable = true;
-        });
-        return this;
-    }
-    emitByPositive(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+    refine(condition) {
+        return this.push((data) => {
             if (condition(data.payload))
                 data.isAvailable = true;
         });
-        return this;
-    }
-    refine(condition) {
-        return this.emitByPositive(condition);
     }
     pushRefiners(conditions) {
         if (!Array.isArray(conditions))
             return this;
         for (let i = 0; i < conditions.length; i++)
-            this.emitByPositive(conditions[i]);
-        return this;
-    }
-    emitMatch(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
-            if (condition(data.payload) == data.payload)
-                data.isAvailable = true;
-        });
+            this.refine(conditions[i]);
         return this;
     }
     switch() {
-        return new SwitchCase(this);
+        return new PipeSwitchCase(this);
     }
     then(condition) {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+        return this.push((data) => {
             data.payload = condition(data.payload);
             data.isAvailable = true;
         });
-        return this;
     }
     serialize() {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+        return this.push((data) => {
             data.payload = JSON.stringify(data.payload);
             data.isAvailable = true;
         });
-        return this;
     }
     deserialize() {
-        const data = this.pipeData;
-        this.chainHandlers.push(() => {
+        return this.push((data) => {
             data.payload = JSON.parse(data.payload);
             data.isAvailable = true;
         });
-        return this;
     }
     processChain(listener) {
-        const chain = this.chainHandlers;
-        const data = this.pipeData;
+        const chain = this.chain;
+        const data = this.flow;
         for (let i = 0; i < chain.length; i++) {
-            data.isNeedUnsubscribe = false;
+            data.isUnsubscribe = false;
             data.isAvailable = false;
-            chain[i]();
-            if (data.isNeedUnsubscribe)
+            chain[i](data);
+            if (data.isUnsubscribe)
                 return this.unsubscribe();
             if (!data.isAvailable)
                 return;
-            if (data.isBreakChain)
+            if (data.isBreak)
                 break;
         }
         return listener(data.payload);
     }
 }
 exports.Pipe = Pipe;
-class SwitchCase {
-    pipe;
-    caseCounter;
-    constructor(pipe) {
-        this.pipe = pipe;
-        this.caseCounter = pipe.chainHandlers.length ? pipe.chainHandlers.length : 0;
-    }
+class PipeSwitchCase extends AbstractSwitchCase_1.SwitchCase {
     subscribe(listener, errorHandler) {
         return this.pipe.subscribe(listener, errorHandler);
     }
-    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;
-    }
-    pushCases(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.case(conditions[i]);
-        return this;
-    }
 }
-exports.SwitchCase = SwitchCase;
+exports.PipeSwitchCase = PipeSwitchCase;

package/src/outLib/SubscribeObject.js

@@ -28,12 +28,12 @@ class SubscribeObject extends Pipe_1.Pipe {
         this.observable.unSubscribe(this);
         this.observable = null;
         this.listener = null;
-        this.chainHandlers.length = 0;
+        this.chain.length = 0;
     }
     send(value) {
         try {
-            this.pipeData.payload = value;
-            this.pipeData.isBreakChain = false;
+            this.flow.payload = value;
+            this.flow.isBreak = false;
             this.processValue(value);
         }
         catch (err) {
@@ -57,7 +57,7 @@ class SubscribeObject extends Pipe_1.Pipe {
         if (!listener)
             return this.unsubscribe();
         if (!this.observable)
-            return this.unsubscribe();
+            return;
         if (this.isPaused)
             return;
         if (!this.isPipe)

package/src/outLib/Types.d.ts

@@ -1,4 +1,4 @@
-import { SwitchCase } from "./Pipe";
+import { PipeSwitchCase } from "./Pipe";
 import { FilterSwitchCase } from "./FilterCollection";
 export type ICallback<T> = (value?: T) => any;
 export type IErrorCallback = (errorData: any, errorMessage: any) => void;
@@ -14,10 +14,10 @@ export type IOrder = {
     order: number;
 };
 export type ISwitch<T> = {
-    switch(): SwitchCase<T>;
+    switch(): PipeSwitchCase<T>;
 };
 export type IOrderedSwitch<T> = {
-    switch(): SwitchCase<T>;
+    switch(): PipeSwitchCase<T>;
 };
 export type IOnce<T> = {
     setOnce(): ISubscribe<T>;
@@ -31,8 +31,8 @@ export type ISetObservableValue = {
 export type ISubscriptionLike = {
     unsubscribe(): void;
 };
-export type ISetup<T> = IUnsubscribeByNegative<T> & IUnsubscribeByPositive<T> & IEmitByNegative<T> & IEmitByPositive<T> & IEmitMatchCondition<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & ISubscribe<T>;
-export type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedSubscribe<T>;
+export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & ISubscribe<T>;
+export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedSubscribe<T>;
 export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
 export type ISubscribeCounter = {
     size(): number;
@@ -70,11 +70,9 @@ export type IOrderedUnsubscribeByNegative<T> = {
     unsubscribeByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
 export type IUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<T>): ISetup<T>;
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
 export type IOrderedUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<T>): IOrderedSetup<T>;
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
 export type IEmitByNegative<T> = {
@@ -84,7 +82,6 @@ export type IOrderedEmitByNegative<T> = {
     emitByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
 export type IEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<T>): ISetup<T>;
     refine(condition: ICallback<T>): ISetup<T>;
     pushRefiners(conditions: ICallback<T>[]): ISetup<T>;
 };
@@ -96,7 +93,6 @@ export type ISerialisation = {
     deserialize<K>(): ISetup<K>;
 };
 export type IOrderedEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): IOrderedSetup<T>;
     refine(condition: ICallback<any>): ISetup<T>;
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
 };
@@ -126,14 +122,17 @@ export type IOrderedSubscriptionLike = (ISubscriptionLike & IOrder);
 export type IOrderedSubscribe<T> = {
     subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
 };
+export type IChainContainer = {
+    chain: any[];
+};
 export type IPipePayload = {
-    isBreakChain: boolean;
-    isNeedUnsubscribe: boolean;
+    isBreak: boolean;
+    isUnsubscribe: boolean;
     isAvailable: boolean;
     payload: any;
 };
-export type IChainCallback = () => void;
-export type IPipeCase<T> = {
+export type IChainCallback = (data: IPipePayload) => void;
+export type IPipeCase<T> = ISubscribe<T> & {
     case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
     pushCases(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
 };
@@ -155,10 +154,11 @@ export type IFilterCase<T> = {
     pushCases(conditions: ICallback<any>[]): IFilterCase<T>;
 };
 export type IFilterPayload = {
-    isBreakChain: boolean;
+    isBreak: boolean;
     isAvailable: boolean;
     payload: any;
 };
+export type IFilterChainCallback = (data: IFilterPayload) => void;
 export type IFilterResponse = {
     isOK: boolean;
     payload: any;