evg_observable 1.6.44 → 1.7.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.6.44",
+  "version": "1.7.44",
   "description": "Alternative fast and light library version - observable.",
   "directories": {
     "test": "test"
@@ -21,7 +21,7 @@
   },
   "homepage": "https://github.com/BarushevEA/light-observable-ts#readme",
   "devDependencies": {
-    "typescript": "^5.4.2",
+    "typescript": "^5.4.5",
     "@testdeck/mocha": "^0.3.3",
     "@types/chai": "^4.3.4",
     "chai": "^4.3.7",

package/repo/evg_observable.js

@@ -1 +1 @@
-(()=>{"use strict";function s(s,e){const i=s.indexOf(e);return-1!==i&&(s[i]=s[s.length-1],s.length=s.length-1,!0)}const e=()=>!1,i=()=>!0,t=()=>"772716b8-e6e2-47ac-95e9-e8d99ce35124",r=(s,e)=>s.order>e.order?1:s.order<e.order?-1:0,n=(s,e)=>s.order>e.order?-1:s.order<e.order?1:0;class o{get order(){return this._order}constructor(s,e){this.isMarkedForUnsubscribe=!1,this.isPipe=!1,this._order=0,this.isListenPaused=!1,this.once={isOnce:!1,isFinished:!1},this.unsubscribeByNegativeCondition=null,this.unsubscribeByPositiveCondition=null,this.emitByNegativeCondition=null,this.emitByPositiveCondition=null,this.emitMatchCondition=null,this.errorHandler=(s,e)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,e)},this.observable=s,this.isPipe=!!e}static callbackSend(s,e){const i=e.listener;return i&&e.observable?e.isListenPaused?void 0:e.isPipe?e.emitByPositiveCondition&&e.emitByPositiveCondition(s)||e.emitByNegativeCondition&&!e.emitByNegativeCondition(s)?i(s):e.once.isOnce?(e.once.isFinished=!0,i(s),e.unsubscribe()):e.unsubscribeByNegativeCondition?e.unsubscribeByNegativeCondition(s)?i(s):(e.unsubscribeByNegativeCondition=null,e.unsubscribe()):e.unsubscribeByPositiveCondition?e.unsubscribeByPositiveCondition(s)?(e.unsubscribeByPositiveCondition=null,e.unsubscribe()):i(s):e.emitMatchCondition&&e.emitMatchCondition(s)===s?i(s):void 0:i(s):e.unsubscribe()}subscribe(s,e){return this.listener=s,e&&(this.errorHandler=e),this}unsubscribe(){this.observable&&(this.observable.unSubscribe(this),this.observable=null,this.listener=null)}send(s){try{o.callbackSend(s,this)}catch(e){this.errorHandler(s,e)}}setOnce(){return this.once.isOnce=!0,this}unsubscribeByNegative(s){return this.unsubscribeByNegativeCondition=s??e,this}unsubscribeByPositive(s){return this.unsubscribeByPositiveCondition=s??i,this}emitByNegative(s){return this.emitByNegativeCondition=s??i,this}emitByPositive(s){return this.emitByPositiveCondition=s??e,this}emitMatch(s){return this.emitMatchCondition=s??t,this}resume(){this.isListenPaused=!1}pause(){this.isListenPaused=!0}set order(s){this._order=s}}class u{get isEnable(){return this._isEnable}constructor(s){this.value=s,this.listeners=[],this._isEnable=!0,this.isNextProcess=!1,this.listenersForUnsubscribe=[],this._isDestroyed=!1}disable(){this._isEnable=!1}enable(){this._isEnable=!0}next(s){if(!this._isDestroyed&&this._isEnable){this.isNextProcess=!0,this.value=s;for(let e=0;e<this.listeners.length;e++)this.listeners[e].send(s);this.isNextProcess=!1,this.listenersForUnsubscribe.length&&this.handleListenersForUnsubscribe()}}stream(s){if(!this._isDestroyed&&this._isEnable)for(let e=0;e<s.length;e++)this.next(s[e])}get isDestroyed(){return this._isDestroyed}unSubscribe(e){if(!this._isDestroyed){if(this.isNextProcess&&e){const s=e;return!s.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(e),void(s.isMarkedForUnsubscribe=!0)}this.listeners&&s(this.listeners,e)}}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._isDestroyed)return;if(!s)return;const i=new o(this,!1);return i.subscribe(s,e),this.listeners.push(i),i}pipe(){if(this._isDestroyed)return;const s=new o(this,!0);return this.listeners.push(s),s}handleListenersForUnsubscribe(){const s=this.listenersForUnsubscribe.length;for(let e=0;e<s;e++)this.unSubscribe(this.listenersForUnsubscribe[e]);this.listenersForUnsubscribe.length=0}}class h extends o{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 this.listener=s,e&&(this.errorHandler=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 b=window;b.Observable=u,b.Collector=class{constructor(){this.list=[],this._isDestroyed=!1}collect(...s){this._isDestroyed||this.list.push(...s)}unsubscribe(e){this._isDestroyed||(e?.unsubscribe(),s(this.list,e))}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}},b.OrderedObservable=class extends u{constructor(){super(...arguments),this.sortDirection=r}setAscendingSort(){return this.sortDirection=r,this.sortByOrder()}setDescendingSort(){return this.sortDirection=n,this.sortByOrder()}sortByOrder(){return!this._isDestroyed&&(this.listeners.sort(this.sortDirection),!0)}subscribe(s,e){if(this._isDestroyed)return;if(!s)return;const i=new h(this,!1);return i.subscribe(s,e),this.listeners.push(i),i}pipe(){if(this._isDestroyed)return;const s=new h(this,!0);return this.listeners.push(s),s}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&function(s,e){const i=s.indexOf(e);-1!==i&&s.splice(i,1)}(this.listeners,s)}}}})();
+(()=>{"use strict";const s=(s,e)=>s.order>e.order?1:s.order<e.order?-1:0,e=(s,e)=>s.order>e.order?-1:s.order<e.order?1:0;function i(s,e){const i=s.indexOf(e);return-1!==i&&(s[i]=s[s.length-1],s.length=s.length-1,!0)}class t{constructor(){this.chainHandlers=[],this.pipeData={isBreakChain:!1,isNeedUnsubscribe:!1,isAvailable:!1,payload:null}}setOnce(){const s=this.pipeData;return this.chainHandlers.push((()=>{this.listener(s.payload),s.isNeedUnsubscribe=!0})),this}unsubscribeByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)||(e.isNeedUnsubscribe=!0)})),this}unsubscribeByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{e.isAvailable=!0,s(e.payload)&&(e.isNeedUnsubscribe=!0)})),this}emitByNegative(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)||(e.isAvailable=!0)})),this}emitByPositive(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)&&(e.isAvailable=!0)})),this}emitMatch(s){const e=this.pipeData;return this.chainHandlers.push((()=>{s(e.payload)==e.payload&&(e.isAvailable=!0)})),this}switch(){return new r(this)}}class r{constructor(s){this.caseCounter=0,this.pipe=s}subscribe(s,e){return this.pipe.subscribe(s,e)}case(s){this.caseCounter++;const e=this.caseCounter,i=this.pipe.pipeData,t=this.pipe.chainHandlers;return t.push((()=>{i.isAvailable=!0,s(i.payload)&&(i.isBreakChain=!0),e!==t.length||i.isBreakChain||(i.isAvailable=!1)})),this}}class n extends t{constructor(s,e){super(),this.isMarkedForUnsubscribe=!1,this.errorHandler=(s,e)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,e)},this._order=0,this.isPaused=!1,this.isPipe=!1,this.observable=s,this.isPipe=!!e}subscribe(s,e){var i;return this.listener="next"in(i=s)?s=>i.next(s):i,e&&(this.errorHandler=e),this}unsubscribe(){this.observable&&(this.observable.unSubscribe(this),this.observable=null,this.listener=null,this.chainHandlers.length=0)}send(s){try{this.pipeData.payload=s,this.pipeData.isBreakChain=!1,function(s,e){const i=e.listener;if(!i)return e.unsubscribe();if(!e.observable)return e.unsubscribe();if(!e.isPaused){if(!e.isPipe)return i(s);for(let s=0;s<e.chainHandlers.length;s++){if(e.pipeData.isNeedUnsubscribe=!1,e.pipeData.isAvailable=!1,e.chainHandlers[s](),e.pipeData.isNeedUnsubscribe)return e.unsubscribe();if(!e.pipeData.isAvailable)return;if(e.pipeData.isBreakChain)break}i(e.pipeData.payload)}}(s,this)}catch(e){this.errorHandler(s,e)}}resume(){this.isPaused=!1}pause(){this.isPaused=!0}get order(){return this._order}set order(s){this._order=s}}class h{constructor(s){this.value=s,this.listeners=[],this._isEnable=!0,this._isDestroyed=!1,this.isNextProcess=!1,this.listenersForUnsubscribe=[]}disable(){this._isEnable=!1}enable(){this._isEnable=!0}get isEnable(){return this._isEnable}next(s){if(!this._isDestroyed&&this._isEnable){this.isNextProcess=!0,this.value=s;for(let e=0;e<this.listeners.length;e++)this.listeners[e].send(s);this.isNextProcess=!1,this.listenersForUnsubscribe.length&&this.handleListenersForUnsubscribe()}}stream(s){if(!this._isDestroyed&&this._isEnable)for(let e=0;e<s.length;e++)this.next(s[e])}handleListenersForUnsubscribe(){const s=this.listenersForUnsubscribe.length;for(let e=0;e<s;e++)this.unSubscribe(this.listenersForUnsubscribe[e]);this.listenersForUnsubscribe.length=0}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&i(this.listeners,s)}}destroy(){this.value=null,this.unsubscribeAll(),this.listeners=null,this._isDestroyed=!0}unsubscribeAll(){this._isDestroyed||(this.listeners.length=0)}getValue(){if(!this._isDestroyed)return this.value}size(){return this._isDestroyed?0:this.listeners.length}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new n(this,!1);return this.addObserver(i,s,e),i}addObserver(s,e,i){s.subscribe(e,i),this.listeners.push(s)}isSubsValid(s){return!this._isDestroyed&&!!s}pipe(){if(this._isDestroyed)return;const s=new n(this,!0);return this.listeners.push(s),s}get isDestroyed(){return this._isDestroyed}}class a extends n{constructor(s,e){super(s,e)}get order(){return this._order}set order(s){!this.observable||this.observable&&this.observable.isDestroyed?this._order=void 0:(this._order=s,this.observable.sortByOrder())}subscribe(s,e){return super.subscribe(s,e),this}setOnce(){return super.setOnce()}unsubscribeByNegative(s){return super.unsubscribeByNegative(s)}unsubscribeByPositive(s){return super.unsubscribeByPositive(s)}emitByNegative(s){return super.emitByNegative(s)}emitByPositive(s){return super.emitByPositive(s)}emitMatch(s){return super.emitMatch(s)}}const u=window;u.Observable=h,u.Collector=class{constructor(){this.list=[],this._isDestroyed=!1}collect(...s){this._isDestroyed||this.list.push(...s)}unsubscribe(s){this._isDestroyed||(s?.unsubscribe(),i(this.list,s))}unsubscribeAll(){if(!this._isDestroyed)for(;this.list.length>0;)this.unsubscribe(this.list.pop())}size(){return this._isDestroyed?0:this.list.length}destroy(){this.unsubscribeAll(),this.list.length=0,this.list=0,this._isDestroyed=!0}get isDestroyed(){return this._isDestroyed}},u.OrderedObservable=class extends h{constructor(){super(...arguments),this.sortDirection=s}setAscendingSort(){return this.sortDirection=s,this.sortByOrder()}setDescendingSort(){return this.sortDirection=e,this.sortByOrder()}sortByOrder(){return!this._isDestroyed&&(this.listeners.sort(this.sortDirection),!0)}subscribe(s,e){if(!this.isSubsValid(s))return;const i=new a(this,!1);return this.addObserver(i,s,e),i}pipe(){if(this._isDestroyed)return;const s=new a(this,!0);return this.listeners.push(s),s}unSubscribe(s){if(!this._isDestroyed){if(this.isNextProcess&&s){const e=s;return!e.isMarkedForUnsubscribe&&this.listenersForUnsubscribe.push(s),void(e.isMarkedForUnsubscribe=!0)}this.listeners&&function(s,e){const i=s.indexOf(e);-1!==i&&s.splice(i,1)}(this.listeners,s)}}}})();

package/src/outLib/FunctionLibs.d.ts

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

package/src/outLib/FunctionLibs.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortDescending = exports.sortAscending = exports.randomCallback = exports.positiveCallback = exports.negativeCallback = exports.quickDeleteFromArray = exports.deleteFromArray = void 0;
+exports.getListener = exports.quickDeleteFromArray = exports.deleteFromArray = exports.sortDescending = exports.sortAscending = void 0;
+const sortAscending = (a, b) => {
+    if (a.order > b.order)
+        return 1;
+    if (a.order < b.order)
+        return -1;
+    return 0;
+};
+exports.sortAscending = sortAscending;
+const sortDescending = (a, b) => {
+    if (a.order > b.order)
+        return -1;
+    if (a.order < b.order)
+        return 1;
+    return 0;
+};
+exports.sortDescending = sortDescending;
 function deleteFromArray(arr, component) {
     const index = arr.indexOf(component);
     if (index === -1)
@@ -18,25 +34,9 @@ function quickDeleteFromArray(arr, component) {
     return true;
 }
 exports.quickDeleteFromArray = quickDeleteFromArray;
-const negativeCallback = () => false;
-exports.negativeCallback = negativeCallback;
-const positiveCallback = () => true;
-exports.positiveCallback = positiveCallback;
-const randomCallback = () => "772716b8-e6e2-47ac-95e9-e8d99ce35124";
-exports.randomCallback = randomCallback;
-const sortAscending = (a, b) => {
-    if (a.order > b.order)
-        return 1;
-    if (a.order < b.order)
-        return -1;
-    return 0;
-};
-exports.sortAscending = sortAscending;
-const sortDescending = (a, b) => {
-    if (a.order > b.order)
-        return -1;
-    if (a.order < b.order)
-        return 1;
-    return 0;
-};
-exports.sortDescending = sortDescending;
+function getListener(listener) {
+    if ("next" in listener)
+        return (value) => listener.next(value);
+    return listener;
+}
+exports.getListener = getListener;

package/src/outLib/Observable.d.ts

@@ -1,34 +1,5 @@
-import { ICallback, IErrorCallback, IListener, IMarkedForUnsubscribe, IObserver, ISetup, IStream, ISubscribe, ISubscribeObject, ISubscriptionLike } from "./Types";
-export declare class SubscribeObject<T> implements ISubscribeObject<T>, IMarkedForUnsubscribe {
-    isMarkedForUnsubscribe: boolean;
-    protected observable: IObserver<T> | undefined;
-    protected listener: IListener<T> | undefined;
-    protected errorHandler: IErrorCallback;
-    protected _order: number;
-    private isListenPaused;
-    private once;
-    private unsubscribeByNegativeCondition;
-    private unsubscribeByPositiveCondition;
-    private emitByNegativeCondition;
-    private emitByPositiveCondition;
-    private emitMatchCondition;
-    protected isPipe: boolean;
-    constructor(observable?: IObserver<T>, isPipe?: boolean);
-    private static callbackSend;
-    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike;
-    unsubscribe(): void;
-    send(value: T): void;
-    setOnce(): ISubscribe<T>;
-    unsubscribeByNegative(condition: ICallback<T>): ISubscribe<T>;
-    unsubscribeByPositive(condition: ICallback<T>): ISubscribe<T>;
-    emitByNegative(condition: ICallback<T>): ISubscribe<T>;
-    emitByPositive(condition: ICallback<T>): ISubscribe<T>;
-    emitMatch(condition: ICallback<T>): ISubscribe<T>;
-    resume(): void;
-    pause(): void;
-    get order(): number;
-    set order(value: number);
-}
+import { IErrorCallback, IListener, IObserver, ISetObservableValue, ISetup, IStream, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { SubscribeObject } from "./SubscribeObject";
 export declare class Observable<T> implements IObserver<T>, IStream<T> {
     private value;
     protected listeners: ISubscribeObject<T>[];
@@ -48,7 +19,9 @@ export declare class Observable<T> implements IObserver<T>, IStream<T> {
     unsubscribeAll(): void;
     getValue(): T | undefined;
     size(): number;
-    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    protected addObserver(subscribeObject: SubscribeObject<T>, observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): void;
+    protected isSubsValid(listener: IListener<T> | ISetObservableValue): boolean;
     pipe(): ISetup<T> | undefined;
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -1,121 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Observable = exports.SubscribeObject = void 0;
+exports.Observable = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
-class SubscribeObject {
-    isMarkedForUnsubscribe = false;
-    observable;
-    listener;
-    errorHandler = (errorData, errorMessage) => {
-        console.log(`(Unit of SubscribeObject).send(${errorData}) ERROR:`, errorMessage);
-    };
-    _order = 0;
-    isListenPaused = false;
-    once = { isOnce: false, isFinished: false };
-    unsubscribeByNegativeCondition = null;
-    unsubscribeByPositiveCondition = null;
-    emitByNegativeCondition = null;
-    emitByPositiveCondition = null;
-    emitMatchCondition = null;
-    isPipe = false;
-    constructor(observable, isPipe) {
-        this.observable = observable;
-        this.isPipe = !!isPipe;
-    }
-    static callbackSend(value, subsObj) {
-        const listener = subsObj.listener;
-        if (!listener)
-            return subsObj.unsubscribe();
-        if (!subsObj.observable)
-            return subsObj.unsubscribe();
-        if (subsObj.isListenPaused)
-            return;
-        if (!subsObj.isPipe)
-            return listener(value);
-        if (subsObj.emitByPositiveCondition && subsObj.emitByPositiveCondition(value))
-            return listener(value);
-        if (subsObj.emitByNegativeCondition && !subsObj.emitByNegativeCondition(value))
-            return listener(value);
-        if (subsObj.once.isOnce) {
-            subsObj.once.isFinished = true;
-            listener(value);
-            return subsObj.unsubscribe();
-        }
-        if (subsObj.unsubscribeByNegativeCondition) {
-            if (!subsObj.unsubscribeByNegativeCondition(value)) {
-                subsObj.unsubscribeByNegativeCondition = null;
-                return subsObj.unsubscribe();
-            }
-            return listener(value);
-        }
-        if (subsObj.unsubscribeByPositiveCondition) {
-            if (subsObj.unsubscribeByPositiveCondition(value)) {
-                subsObj.unsubscribeByPositiveCondition = null;
-                return subsObj.unsubscribe();
-            }
-            return listener(value);
-        }
-        if (subsObj.emitMatchCondition && (subsObj.emitMatchCondition(value) === value))
-            return listener(value);
-    }
-    subscribe(listener, errorHandler) {
-        this.listener = listener;
-        errorHandler && (this.errorHandler = errorHandler);
-        return this;
-    }
-    unsubscribe() {
-        if (!this.observable)
-            return;
-        this.observable.unSubscribe(this);
-        this.observable = null;
-        this.listener = null;
-    }
-    send(value) {
-        try {
-            SubscribeObject.callbackSend(value, this);
-        }
-        catch (err) {
-            this.errorHandler(value, err);
-        }
-    }
-    setOnce() {
-        this.once.isOnce = true;
-        return this;
-    }
-    unsubscribeByNegative(condition) {
-        this.unsubscribeByNegativeCondition = condition ?? FunctionLibs_1.negativeCallback;
-        return this;
-    }
-    unsubscribeByPositive(condition) {
-        this.unsubscribeByPositiveCondition = condition ?? FunctionLibs_1.positiveCallback;
-        return this;
-    }
-    emitByNegative(condition) {
-        this.emitByNegativeCondition = condition ?? FunctionLibs_1.positiveCallback;
-        return this;
-    }
-    emitByPositive(condition) {
-        this.emitByPositiveCondition = condition ?? FunctionLibs_1.negativeCallback;
-        return this;
-    }
-    emitMatch(condition) {
-        this.emitMatchCondition = condition ?? FunctionLibs_1.randomCallback;
-        return this;
-    }
-    resume() {
-        this.isListenPaused = false;
-    }
-    pause() {
-        this.isListenPaused = true;
-    }
-    get order() {
-        return this._order;
-    }
-    set order(value) {
-        this._order = value;
-    }
-}
-exports.SubscribeObject = SubscribeObject;
+const SubscribeObject_1 = require("./SubscribeObject");
 class Observable {
     value;
     listeners = [];
@@ -193,20 +80,26 @@ class Observable {
             return 0;
         return this.listeners.length;
     }
-    subscribe(listener, errorHandler) {
-        if (this._isDestroyed)
-            return undefined;
-        if (!listener)
+    subscribe(observer, errorHandler) {
+        if (!this.isSubsValid(observer))
             return undefined;
-        const subscribeObject = new SubscribeObject(this, false);
-        subscribeObject.subscribe(listener, errorHandler);
-        this.listeners.push(subscribeObject);
+        const subscribeObject = new SubscribeObject_1.SubscribeObject(this, false);
+        this.addObserver(subscribeObject, observer, errorHandler);
         return subscribeObject;
     }
+    addObserver(subscribeObject, observer, errorHandler) {
+        subscribeObject.subscribe(observer, errorHandler);
+        this.listeners.push(subscribeObject);
+    }
+    isSubsValid(listener) {
+        if (this._isDestroyed)
+            return false;
+        return !!listener;
+    }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new SubscribeObject(this, true);
+        const subscribeObject = new SubscribeObject_1.SubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }

package/src/outLib/OrderedObservable.d.ts

@@ -1,23 +1,11 @@
-import { Observable, SubscribeObject } from "./Observable";
-import { ICallback, IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISubscriptionLike } from "./Types";
-export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> {
-    constructor(observable: OrderedObservable<T> | IOrdered<T>, isPipe?: boolean);
-    get order(): number;
-    set order(value: number);
-    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
-    setOnce(): IOrderedSubscribe<T>;
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-    emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-    emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-    emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
-}
+import { Observable } from "./Observable";
+import { IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscriptionLike, ISetObservableValue, ISubscriptionLike } from "./Types";
 export declare class OrderedObservable<T> extends Observable<T> implements IOrdered<T> {
     private sortDirection;
     setAscendingSort(): boolean;
     setDescendingSort(): boolean;
     sortByOrder(): boolean;
-    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike | undefined;
+    subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike | undefined;
     pipe(): IOrderedSetup<T> | undefined;
     unSubscribe(listener: ISubscriptionLike): void;
 }

package/src/outLib/OrderedObservable.js

@@ -1,49 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderedObservable = exports.OrderedSubscribeObject = void 0;
+exports.OrderedObservable = void 0;
 const Observable_1 = require("./Observable");
 const FunctionLibs_1 = require("./FunctionLibs");
-class OrderedSubscribeObject extends Observable_1.SubscribeObject {
-    constructor(observable, isPipe) {
-        super(observable, isPipe);
-    }
-    get order() {
-        return this._order;
-    }
-    set order(value) {
-        if (!this.observable ||
-            (this.observable && this.observable.isDestroyed)) {
-            this._order = undefined;
-            return;
-        }
-        this._order = value;
-        this.observable.sortByOrder();
-    }
-    subscribe(listener, errorHandler) {
-        this.listener = listener;
-        errorHandler && (this.errorHandler = errorHandler);
-        return this;
-    }
-    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;
+const OrderedSubscribeObject_1 = require("./OrderedSubscribeObject");
 class OrderedObservable extends Observable_1.Observable {
     sortDirection = FunctionLibs_1.sortAscending;
     setAscendingSort() {
@@ -61,19 +21,16 @@ class OrderedObservable extends Observable_1.Observable {
         return true;
     }
     subscribe(listener, errorHandler) {
-        if (this._isDestroyed)
+        if (!this.isSubsValid(listener))
             return undefined;
-        if (!listener)
-            return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, false);
-        subscribeObject.subscribe(listener, errorHandler);
-        this.listeners.push(subscribeObject);
+        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, false);
+        this.addObserver(subscribeObject, listener, errorHandler);
         return subscribeObject;
     }
     pipe() {
         if (this._isDestroyed)
             return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, true);
+        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, true);
         this.listeners.push(subscribeObject);
         return subscribeObject;
     }

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -0,0 +1,15 @@
+import { SubscribeObject } from "./SubscribeObject";
+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);
+    get order(): number;
+    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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderedSubscribeObject = void 0;
+const SubscribeObject_1 = require("./SubscribeObject");
+class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
+    constructor(observable, isPipe) {
+        super(observable, isPipe);
+    }
+    get order() {
+        return this._order;
+    }
+    set order(value) {
+        if (!this.observable ||
+            (this.observable && this.observable.isDestroyed)) {
+            this._order = undefined;
+            return;
+        }
+        this._order = value;
+        this.observable.sortByOrder();
+    }
+    subscribe(observer, errorHandler) {
+        super.subscribe(observer, errorHandler);
+        return this;
+    }
+    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

@@ -0,0 +1,20 @@
+import { ICallback, IChainCallback, IErrorCallback, IListener, IPipeCase, IPipePayload, ISetObservableValue, ISetup, ISubscribe, ISubscriptionLike } from "./Types";
+export declare abstract class Pipe<T> implements ISubscribe<T> {
+    chainHandlers: IChainCallback[];
+    pipeData: IPipePayload;
+    abstract subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    setOnce(): ISubscribe<T>;
+    unsubscribeByNegative(condition: ICallback<T>): ISetup<T>;
+    unsubscribeByPositive(condition: ICallback<T>): ISetup<T>;
+    emitByNegative(condition: ICallback<T>): ISetup<T>;
+    emitByPositive(condition: ICallback<T>): ISetup<T>;
+    emitMatch(condition: ICallback<T>): ISetup<T>;
+    switch(): SwitchCase<T>;
+}
+export declare class SwitchCase<T> implements ISubscribe<T>, IPipeCase<T> {
+    private pipe;
+    private caseCounter;
+    constructor(pipe: Pipe<T>);
+    subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
+}

package/src/outLib/Pipe.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchCase = exports.Pipe = void 0;
+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;
+        });
+        return this;
+    }
+    unsubscribeByNegative(condition) {
+        const data = this.pipeData;
+        this.chainHandlers.push(() => {
+            data.isAvailable = true;
+            if (!condition(data.payload))
+                data.isNeedUnsubscribe = true;
+        });
+        return this;
+    }
+    unsubscribeByPositive(condition) {
+        const data = this.pipeData;
+        this.chainHandlers.push(() => {
+            data.isAvailable = true;
+            if (condition(data.payload))
+                data.isNeedUnsubscribe = true;
+        });
+        return this;
+    }
+    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(() => {
+            if (condition(data.payload))
+                data.isAvailable = true;
+        });
+        return this;
+    }
+    emitMatch(condition) {
+        const data = this.pipeData;
+        this.chainHandlers.push(() => {
+            if (condition(data.payload) == data.payload)
+                data.isAvailable = true;
+        });
+        return this;
+    }
+    switch() {
+        return new SwitchCase(this);
+    }
+}
+exports.Pipe = Pipe;
+class SwitchCase {
+    pipe;
+    caseCounter = 0;
+    constructor(pipe) {
+        this.pipe = pipe;
+    }
+    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;
+    }
+}
+exports.SwitchCase = SwitchCase;

package/src/outLib/SubscribeObject.d.ts

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

package/src/outLib/SubscribeObject.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeObject = void 0;
+const Pipe_1 = require("./Pipe");
+const FunctionLibs_1 = require("./FunctionLibs");
+class SubscribeObject extends Pipe_1.Pipe {
+    isMarkedForUnsubscribe = false;
+    observable;
+    listener;
+    errorHandler = (errorData, errorMessage) => {
+        console.log(`(Unit of SubscribeObject).send(${errorData}) ERROR:`, errorMessage);
+    };
+    _order = 0;
+    isPaused = false;
+    isPipe = false;
+    constructor(observable, isPipe) {
+        super();
+        this.observable = observable;
+        this.isPipe = !!isPipe;
+    }
+    subscribe(observer, errorHandler) {
+        this.listener = (0, FunctionLibs_1.getListener)(observer);
+        errorHandler && (this.errorHandler = errorHandler);
+        return this;
+    }
+    unsubscribe() {
+        if (!this.observable)
+            return;
+        this.observable.unSubscribe(this);
+        this.observable = null;
+        this.listener = null;
+        this.chainHandlers.length = 0;
+    }
+    send(value) {
+        try {
+            this.pipeData.payload = value;
+            this.pipeData.isBreakChain = false;
+            processValue(value, this);
+        }
+        catch (err) {
+            this.errorHandler(value, err);
+        }
+    }
+    resume() {
+        this.isPaused = false;
+    }
+    pause() {
+        this.isPaused = true;
+    }
+    get order() {
+        return this._order;
+    }
+    set order(value) {
+        this._order = value;
+    }
+}
+exports.SubscribeObject = SubscribeObject;
+function processValue(value, subsObj) {
+    const listener = subsObj.listener;
+    if (!listener)
+        return subsObj.unsubscribe();
+    if (!subsObj.observable)
+        return subsObj.unsubscribe();
+    if (subsObj.isPaused)
+        return;
+    if (!subsObj.isPipe)
+        return listener(value);
+    for (let i = 0; i < subsObj.chainHandlers.length; i++) {
+        subsObj.pipeData.isNeedUnsubscribe = false;
+        subsObj.pipeData.isAvailable = false;
+        subsObj.chainHandlers[i]();
+        if (subsObj.pipeData.isNeedUnsubscribe)
+            return subsObj.unsubscribe();
+        if (!subsObj.pipeData.isAvailable)
+            return;
+        if (subsObj.pipeData.isBreakChain)
+            break;
+    }
+    return listener(subsObj.pipeData.payload);
+}

package/src/outLib/Types.d.ts

@@ -1,23 +1,26 @@
+import { SwitchCase } from "./Pipe";
 export type ICallback<T> = (value?: T) => any;
 export type IMarkedForUnsubscribe = {
     isMarkedForUnsubscribe: boolean;
 };
 export type IErrorCallback = (errorData: any, errorMessage: any) => void;
 export type ISubscribe<T> = {
-    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+    subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
 };
 export type IListener<T> = ICallback<T>;
 export type IDestroy = {
     destroy(): void;
     isDestroyed: boolean;
 };
-export type IOnceMarker = {
-    isOnce: boolean;
-    isFinished: boolean;
-};
 export type IOrder = {
     order: number;
 };
+export type ISwitch<T> = {
+    switch(): SwitchCase<T>;
+};
+export type IOrderedSwitch<T> = {
+    switch(): SwitchCase<T>;
+};
 export type IOnce<T> = {
     setOnce(): ISubscribe<T>;
 };
@@ -30,8 +33,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> & ISubscribe<T>;
-export type IOrderedSetup<T> = IOrderedUnsubscribeByNegative<T> & IOrderedUnsubscribeByPositive<T> & IOrderedEmitByNegative<T> & IOrderedEmitByPositive<T> & IOrderedEmitMatchCondition<T> & IOrderedOnce<T> & IOrderedSubscribe<T>;
+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 ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
 export type ISubscribeCounter = {
     size(): number;
@@ -56,38 +59,41 @@ export type IPause = {
 export type IObservablePipe<T> = {
     pipe(): ISetup<T> | undefined;
 };
+export type IOrderedObservablePipe<T> = {
+    pipe(): ISetup<T> | undefined;
+};
 export type ISend<T> = {
     send(value: T): void;
 };
 export type IUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
+    unsubscribeByNegative(condition: ICallback<any>): ISetup<T>;
 };
 export type IOrderedUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
+    unsubscribeByNegative(condition: ICallback<any>): IOrderedSetup<T>;
 };
 export type IUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;
+    unsubscribeByPositive(condition: ICallback<any>): ISetup<T>;
 };
 export type IOrderedUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
+    unsubscribeByPositive(condition: ICallback<any>): IOrderedSetup<T>;
 };
 export type IEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): ISubscribe<T>;
+    emitByNegative(condition: ICallback<any>): ISetup<T>;
 };
 export type IOrderedEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
+    emitByNegative(condition: ICallback<any>): IOrderedSetup<T>;
 };
 export type IEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): ISubscribe<T>;
+    emitByPositive(condition: ICallback<any>): ISetup<T>;
 };
 export type IOrderedEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
+    emitByPositive(condition: ICallback<any>): IOrderedSetup<T>;
 };
 export type IEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): ISubscribe<T>;
+    emitMatch(condition: ICallback<any>): ISetup<T>;
 };
 export type IOrderedEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
+    emitMatch(condition: ICallback<any>): IOrderedSetup<T>;
 };
 export type ICollector = IDestroy & ISubscribeCounter & {
     collect(...subscriptionLikeList: ISubscriptionLike[]): void;
@@ -97,12 +103,18 @@ export type ICollector = IDestroy & ISubscribeCounter & {
 export type IOrderedObservable = {
     sortByOrder(): boolean;
 };
-export type IOrdered<T> = IObserver<T> & IOrderedObservable;
+export type IOrdered<T> = IObserver<T> & IOrderedObservable & IOrderedObservablePipe<T>;
 export type IOrderedSubscriptionLike = (ISubscriptionLike & IOrder);
 export type IOrderedSubscribe<T> = {
     subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
 };
-export type IGroup = ICollector & {
-    name: string;
-    order: number;
+export type IPipePayload = {
+    isBreakChain: boolean;
+    isNeedUnsubscribe: boolean;
+    isAvailable: boolean;
+    payload: any;
+};
+export type IChainCallback = () => void;
+export type IPipeCase<T> = {
+    case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
 };