evg_observable 1.10.49 → 1.11.50

package/README.md

@@ -444,6 +444,14 @@ const menFilter = (person: Person) => person.gender === GENDER.MAN;
 const womenFilter = (person: Person) => person.gender === GENDER.WOMAN;
 const blondFilter = (person: Person) => person.hairColor === HAIR.BLOND;
 const blackFilter = (person: Person) => person.hairColor === HAIR.BLACK;
+const personValidationFilters = [
+    (person: Person) => !!person,
+    (person: Person) => "name" in person,
+    (person: Person) => "age" in person,
+    (person: Person) => "gender" in person,
+    (person: Person) => "major" in person,
+    (person: Person) => "hairColor" in person,
+];
 
 // Callback function to execute when some man is ready to work
 const manReadyToWork = (worker: Person) => {
@@ -462,14 +470,20 @@ const blondAndBlack = (person: Person) => {
 
 // Apply the filters to men$ and women$
 men$.addFilter()
+    .pushFilters(personValidationFilters)
     .filter(menFilter);
 
 women$.addFilter()
+    .pushFilters(personValidationFilters)
     .filter(womenFilter);
 
 // Subscribe the callback function to the created Observables
-men$.subscribe(manReadyToWork);
-women$.subscribe(womanReadyToWork);
+men$.pipe()
+    .pushRefiners(personValidationFilters)
+    .subscribe(manReadyToWork);
+women$.pipe()
+    .pushRefiners(personValidationFilters)
+    .subscribe(womanReadyToWork);
 
 // Stream the list of people by applying the age filters
 personal$.pipe()
@@ -520,6 +534,40 @@ 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
@@ -542,20 +590,21 @@ 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                                                                      |
+| `.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.49",
+  "version": "1.11.50",
   "description": "Alternative fast and light library version - observable.",
   "directories": {
     "test": "test"

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

@@ -8,7 +8,8 @@ export declare abstract class Pipe<T> implements ISubscribe<T> {
     unsubscribeByPositive(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

@@ -49,6 +49,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;
@@ -82,15 +82,21 @@ export type IOrderedEmitByNegative<T> = {
     emitByNegative(condition: ICallback<any>): 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>;
 };