evg_observable 1.10.50 → 1.11.51

package/README.md

@@ -172,44 +172,7 @@ observable$.next('Next2 typed data');
 // subscriber1 is automatically unsubscribed after first usage
 ```
 
-### pipe().unsubscribeByNegative(condition)
-
-Observable will send a value to the subscriber as long as the condition is positive, on the first negative result, the
-subscriber will unsubscribe.
-
-```ts
-import {Observable} from "evg_observable/src/outLib/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);
-let isPositive = true;
-
-const subscriber1 = observable$
-    .pipe()
-    .unsubscribeByNegative(() => isPositive)
-    .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 - listener1: Next1 typed data
-// Print to console - listener2: Next1 typed data
-
-observable$.next('Next2 typed data');
-// Print to console - listener1: Next2 typed data
-// Print to console - listener2: Next2 typed data
-
-isPositive = false;
-observable$.next('Next3 typed data');
-// Print to console - listener2: Next3 typed data
-
-// subscriber1 is automatically unsubscribed when negative condition
-```
-
-### pipe().unsubscribeByPositive(condition)
+### pipe().unsubscribeBy(condition)
 
 Observable will send a value to the subscriber as long as the condition is negative, on the first positive result, the
 subscriber will unsubscribe.
@@ -217,40 +180,39 @@ subscriber will unsubscribe.
 ```ts
 import {Observable} from "evg_observable/src/outLib/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);
-let isPositive = false;
+type ISomeData = {
+    message: string;
+    isNeedUnsubscribe: boolean;
+}
 
-const subscriber1 = observable$
+const observable$ = new Observable<ISomeData>({message: "some message", isNeedUnsubscribe: false});
+const listener1 = (value: ISomeData) => console.log('listener1:', value);
+const listener2 = (value: ISomeData) => console.log('listener2:', value);
+
+observable$
     .pipe()
-    .unsubscribeByPositive(() => isPositive)
+    .unsubscribeBy((data: ISomeData) => data.isNeedUnsubscribe)
     .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 - listener1: Next1 typed data
-// Print to console - listener2: Next1 typed data
 
-observable$.next('Next2 typed data');
-// Print to console - listener1: Next2 typed data
-// Print to console - listener2: Next2 typed data
+observable$
+    .subscribe(listener2);
 
-isPositive = true;
-observable$.next('Next3 typed data');
-// Print to console - listener2: Next3 typed data
+console.log(observable$.getValue());
 
-// subscriber1 is automatically unsubscribed when positive condition
+observable$.next({message: "some message1", isNeedUnsubscribe: false});
+observable$.next({message: "some message2", isNeedUnsubscribe: false});
+observable$.next({message: "some message3", isNeedUnsubscribe: true});
+
+// logs:
+// { message: 'some message', isNeedUnsubscribe: false }
+// listener1: { message: 'some message1', isNeedUnsubscribe: false }
+// listener2: { message: 'some message1', isNeedUnsubscribe: false }
+// listener1: { message: 'some message2', isNeedUnsubscribe: false }
+// listener2: { message: 'some message2', isNeedUnsubscribe: false }
+// listener2: { message: 'some message3', isNeedUnsubscribe: true }
 ```
 
-### pipe().emitByNegative(condition)
-
-Observable will send a value to the listener only if condition returns "false". There is no automatic unsubscription.
-
-### pipe().emitByPositive(condition)
+### pipe().refine(condition)
 
 Observable will send a value to the listener only if condition returns "true". There is no automatic unsubscription.
 
@@ -534,6 +496,45 @@ Observable an invaluable tool for managing asynchronous events.
 Built with the developer's needs in mind, EVG Observable provides a wealth of capabilities at your disposal, making
 event handling a breeze.
 
+Here is an advanced example of the `pipe` usage which introduces a new method called `then`. It allows transforming
+payload data in the pipe chain by applying a user callback function.
+
+Here is the syntax:
+
+```typescript
+const targetObservable$ = new Observable("");
+const targetListener = (num: number) => console.log(num);
+
+targetObservable$
+    .pipe()
+    .refine(str => str.includes("2"))      // check if a string contains "2"
+    .then<number>(str => str.length)       // transform the string to its length
+    .refine(num => num > 4)                // filter out the lengths that is greater than 4
+    .then<number>(num => num * 2)          // multiply the length by 2
+    .setOnce()                             // make sure this action only happens once
+    .subscribe(targetListener);            // subscribe the listener to the observable
+
+targetObservable$.stream([
+    "1",
+    "12",
+    "123",
+    "123",
+    "1234",
+    "12345",
+    "12345",
+    "12345",
+    "12345",
+    "12345",
+    "12345",
+    "12345",
+]);
+```
+
+In this example, the observable is first refined with a condition to check for a string that includes "2". This string,
+if it passes the condition, is then transformed into its length via a then invocation. Further, this length is filtered
+down to lengths that are greater than 4. The lengths that pass this condition are thus doubled and the resulting
+observable is set to be a once-off observable to which a listener is subscribed. `
+
 ## Methods
 
 ### Observable
@@ -556,20 +557,22 @@ event handling a breeze.
 
 ### Observable`.pipe()`
 
-| 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                                                                      |
-| `.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.                                                                                                                     |
-| `.subscribe(listener)`               | subscriber        | subscribe listener to observable                                                                                                                                                                                        |
+| 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.                                                                                                                     |
+| `.then<K>(condition: ICallback<T>)`  | Observable instance with new data type | This method allows transforming payload data in the pipe chain by applying user callback function. `condition` should be a function that takes the current data and returns transformed data of possibly another type.  |
+| `.subscribe(listener)`               | subscriber                             | subscribe listener to observable                                                                                                                                                                                        |
 
 _*condition_ - this is a function that should return a value that will affect the behavior of the subscriber
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.10.50",
+  "version": "1.11.51",
   "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)}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}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)}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)}refine(s){return super.emitByPositive(s)}pushRefiners(s){return super.pushRefiners(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,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}refine(s){return this.emitByPositive(s)}then(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.payload=s(e.payload),e.isAvailable=!0})),this}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)}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))}}})();

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -1,5 +1,5 @@
 import { SubscribeObject } from "./SubscribeObject";
-import { ICallback, IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISetObservableValue, ISetup } from "./Types";
+import { ICallback, 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);
@@ -11,7 +11,5 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implem
     unsubscribeByPositive(condition: ICallback<any>): IOrderedSetup<T>;
     emitByNegative(condition: ICallback<any>): IOrderedSetup<T>;
     emitByPositive(condition: ICallback<any>): IOrderedSetup<T>;
-    refine(condition: ICallback<any>): ISetup<T>;
-    pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
     emitMatch(condition: ICallback<any>): IOrderedSetup<T>;
 }

package/src/outLib/OrderedSubscribeObject.js

@@ -37,12 +37,6 @@ class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
     emitByPositive(condition) {
         return super.emitByPositive(condition);
     }
-    refine(condition) {
-        return super.emitByPositive(condition);
-    }
-    pushRefiners(conditions) {
-        return super.pushRefiners(conditions);
-    }
     emitMatch(condition) {
         return super.emitMatch(condition);
     }

package/src/outLib/Pipe.d.ts

@@ -6,9 +6,11 @@ export declare abstract class Pipe<T> implements ISubscribe<T> {
     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<any>): ISetup<T>;
+    refine(condition: ICallback<T>): ISetup<T>;
+    then<K>(condition: ICallback<T>): ISetup<K>;
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
     emitMatch(condition: ICallback<T>): ISetup<T>;
     switch(): SwitchCase<T>;

package/src/outLib/Pipe.js

@@ -30,6 +30,9 @@ class Pipe {
         });
         return this;
     }
+    unsubscribeBy(condition) {
+        return this.unsubscribeByPositive(condition);
+    }
     emitByNegative(condition) {
         const data = this.pipeData;
         this.chainHandlers.push(() => {
@@ -49,6 +52,14 @@ class Pipe {
     refine(condition) {
         return this.emitByPositive(condition);
     }
+    then(condition) {
+        const data = this.pipeData;
+        this.chainHandlers.push(() => {
+            data.payload = condition(data.payload);
+            data.isAvailable = true;
+        });
+        return this;
+    }
     pushRefiners(conditions) {
         if (!Array.isArray(conditions))
             return this;

package/src/outLib/Types.d.ts

@@ -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> & ISubscribe<T>;
-export type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedSubscribe<T>;
+export type ISetup<T> = IUnsubscribeByNegative<T> & IUnsubscribeByPositive<T> & IEmitByNegative<T> & IEmitByPositive<T> & IEmitMatchCondition<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISubscribe<T>;
+export type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSubscribe<T>;
 export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
 export type ISubscribeCounter = {
     size(): number;
@@ -64,33 +64,41 @@ export type ISend<T> = {
     send(value: T): void;
 };
 export type IUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): ISetup<T>;
+    unsubscribeByNegative(condition: ICallback<T>): ISetup<T>;
 };
 export type IOrderedUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSetup<T>;
+    unsubscribeByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
 export type IUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): ISetup<T>;
+    unsubscribeByPositive(condition: ICallback<T>): ISetup<T>;
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
 export type IOrderedUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSetup<T>;
+    unsubscribeByPositive(condition: ICallback<T>): IOrderedSetup<T>;
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
 };
 export type IEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): ISetup<T>;
+    emitByNegative(condition: ICallback<T>): ISetup<T>;
 };
 export type IOrderedEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): IOrderedSetup<T>;
+    emitByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
 export type IEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): ISetup<T>;
-    refine(condition: ICallback<any>): ISetup<T>;
-    pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
+    emitByPositive(condition: ICallback<T>): ISetup<T>;
+    refine(condition: ICallback<T>): ISetup<T>;
+    pushRefiners(conditions: ICallback<T>[]): ISetup<T>;
+};
+export type ITransform<T> = {
+    then<K>(condition: ICallback<T>): ISetup<K>;
 };
 export type IOrderedEmitByPositive<T> = {
     emitByPositive(condition: ICallback<any>): IOrderedSetup<T>;
     refine(condition: ICallback<any>): ISetup<T>;
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
 };
+export type IOrderedTransform<T> = {
+    then<K>(condition: ICallback<T>): ISetup<K>;
+};
 export type IEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): ISetup<T>;
 };