evg_observable 2.14.61 → 2.15.0

package/src/outLib/{index.d.ts → src/Libraries/Observables/index.d.ts}

@@ -3,3 +3,4 @@ export { OrderedObservable } from './OrderedObservable';
 export { Collector } from './Collector';
 export { deleteFromArray } from './FunctionLibs';
 export { quickDeleteFromArray } from './FunctionLibs';
+export { ISubscriptionLike, IOrderedSubscriptionLike } from './Types';

package/repo/evg_observable.js

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

package/src/outLib/AbstractSwitchCase.d.ts

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

package/src/outLib/AbstractSwitchCase.js

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

package/src/outLib/Collector.d.ts

@@ -1,11 +0,0 @@
-import { ICollector, ISubscriptionLike } from "./Types";
-export declare class Collector implements ICollector {
-    protected arr: ISubscriptionLike[];
-    private killed;
-    collect(...subscriptionLikeList: ISubscriptionLike[]): void;
-    unsubscribe(subscriptionLike: ISubscriptionLike | undefined): void;
-    unsubscribeAll(): void | null;
-    size(): number;
-    destroy(): void;
-    get isDestroyed(): boolean;
-}

package/src/outLib/Collector.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collector = void 0;
-const FunctionLibs_1 = require("./FunctionLibs");
-class Collector {
-    arr = [];
-    killed = false;
-    collect(...subscriptionLikeList) {
-        if (!this.killed)
-            this.arr.push(...subscriptionLikeList);
-    }
-    unsubscribe(subscriptionLike) {
-        if (this.killed)
-            return;
-        subscriptionLike?.unsubscribe();
-        (0, FunctionLibs_1.quickDeleteFromArray)(this.arr, subscriptionLike);
-    }
-    unsubscribeAll() {
-        if (this.killed)
-            return;
-        while (this.arr.length > 0)
-            this.unsubscribe(this.arr.pop());
-    }
-    size() {
-        if (this.killed)
-            return 0;
-        return this.arr.length;
-    }
-    destroy() {
-        this.unsubscribeAll();
-        this.arr.length = 0;
-        this.arr = 0;
-        this.killed = true;
-    }
-    get isDestroyed() {
-        return this.killed;
-    }
-}
-exports.Collector = Collector;

package/src/outLib/FilterCollection.d.ts

@@ -1,17 +0,0 @@
-import { ICallback, IErrorCallback, IFilter, IFilterCase, IFilterChainCallback, IFilterPayload, IFilterResponse, IFilterSetup, IFilterSwitch } from "./Types";
-import { SwitchCase } from "./AbstractSwitchCase";
-export declare class FilterCollection<T> implements IFilter<T>, IFilterSwitch<T> {
-    chain: IFilterChainCallback[];
-    flow: IFilterPayload;
-    response: IFilterResponse;
-    private errHandler;
-    get isEmpty(): boolean;
-    private push;
-    filter(condition: ICallback<any>): IFilterSetup<T>;
-    pushFilters(conditions: ICallback<any>[]): IFilterSetup<T>;
-    switch(): FilterSwitchCase<T>;
-    processChain(value: T): IFilterResponse;
-    addErrorHandler(errorHandler: IErrorCallback): void;
-}
-export declare class FilterSwitchCase<T> extends SwitchCase<T, FilterCollection<T>, IFilterCase<T>> {
-}

package/src/outLib/FilterCollection.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterSwitchCase = exports.FilterCollection = void 0;
-const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
-class FilterCollection {
-    chain = [];
-    flow = { isBreak: false, isAvailable: false, payload: null };
-    response = { isOK: false, payload: undefined };
-    errHandler;
-    get isEmpty() {
-        return !this.chain.length;
-    }
-    push(callback) {
-        this.chain.push(callback);
-        return this;
-    }
-    filter(condition) {
-        return this.push((data) => condition(data.payload) && (data.isAvailable = true));
-    }
-    pushFilters(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.filter(conditions[i]);
-        return this;
-    }
-    switch() {
-        return new FilterSwitchCase(this);
-    }
-    processChain(value) {
-        const chain = this.chain;
-        const data = this.flow;
-        const response = this.response;
-        response.isOK = false;
-        response.payload = undefined;
-        data.payload = value;
-        data.isBreak = false;
-        try {
-            for (let i = 0; i < chain.length; i++) {
-                data.isAvailable = false;
-                chain[i](data);
-                if (!data.isAvailable)
-                    return response;
-                if (data.isBreak)
-                    break;
-            }
-        }
-        catch (err) {
-            if (this.errHandler) {
-                this.errHandler(err, "Filter.processChain ERROR:");
-            }
-            else {
-                console.log("Filter.processChain ERROR:", err);
-            }
-            return response;
-        }
-        response.isOK = true;
-        response.payload = data.payload;
-        return response;
-    }
-    addErrorHandler(errorHandler) {
-        this.errHandler = errorHandler;
-    }
-}
-exports.FilterCollection = FilterCollection;
-class FilterSwitchCase extends AbstractSwitchCase_1.SwitchCase {
-}
-exports.FilterSwitchCase = FilterSwitchCase;

package/src/outLib/FunctionLibs.d.ts

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

package/src/outLib/FunctionLibs.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getListener = exports.quickDeleteFromArray = exports.deleteFromArray = exports.sortDescending = exports.sortAscending = void 0;
-function sortAscending(a, b) {
-    if (a.order > b.order)
-        return 1;
-    if (a.order < b.order)
-        return -1;
-    return 0;
-}
-exports.sortAscending = sortAscending;
-function 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)
-        return false;
-    arr.splice(index, 1);
-    return true;
-}
-exports.deleteFromArray = deleteFromArray;
-function quickDeleteFromArray(arr, component) {
-    const index = arr.indexOf(component);
-    if (index === -1)
-        return false;
-    arr[index] = arr[arr.length - 1];
-    arr.length = arr.length - 1;
-    return true;
-}
-exports.quickDeleteFromArray = quickDeleteFromArray;
-function getListener(listener) {
-    if (Array.isArray(listener)) {
-        const group = [];
-        for (let i = 0; i < listener.length; i++)
-            group.push(wrapListener(listener[i]));
-        return (data) => {
-            for (let i = 0; i < group.length; i++)
-                group[i](data);
-        };
-    }
-    return wrapListener(listener);
-}
-exports.getListener = getListener;
-function wrapListener(listener) {
-    if ("next" in listener)
-        return (value) => listener.next(value);
-    return listener;
-}

package/src/outLib/Observable.d.ts

@@ -1,29 +0,0 @@
-import { IAddFilter, IErrorCallback, IFilterSetup, IObserver, ISetup, IStream, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
-import { SubscribeObject } from "./SubscribeObject";
-export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilter<T> {
-    private value;
-    protected subs: ISubscribeObject<T>[];
-    private enabled;
-    protected killed: boolean;
-    protected process: boolean;
-    protected trash: ISubscriptionLike[];
-    private filters;
-    constructor(value: T);
-    addFilter(errorHandler?: IErrorCallback): IFilterSetup<T>;
-    disable(): void;
-    enable(): void;
-    get isEnable(): boolean;
-    next(value: T): void;
-    stream(values: T[]): void;
-    private clearTrash;
-    unSubscribe(listener: ISubscriptionLike): void;
-    destroy(): void;
-    unsubscribeAll(): void;
-    getValue(): T | undefined;
-    size(): number;
-    subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
-    protected addObserver(subscribeObject: SubscribeObject<T>, observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): void;
-    protected isListener(listener: ISubscribeGroup<T>): boolean;
-    pipe(): ISetup<T> | undefined;
-    get isDestroyed(): boolean;
-}

package/src/outLib/Observable.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Observable = void 0;
-const FunctionLibs_1 = require("./FunctionLibs");
-const SubscribeObject_1 = require("./SubscribeObject");
-const FilterCollection_1 = require("./FilterCollection");
-class Observable {
-    value;
-    subs = [];
-    enabled = true;
-    killed = false;
-    process = false;
-    trash = [];
-    filters = new FilterCollection_1.FilterCollection();
-    constructor(value) {
-        this.value = value;
-    }
-    addFilter(errorHandler) {
-        if (errorHandler)
-            this.filters.addErrorHandler(errorHandler);
-        return this.filters;
-    }
-    disable() {
-        this.enabled = false;
-    }
-    enable() {
-        this.enabled = true;
-    }
-    get isEnable() {
-        return this.enabled;
-    }
-    next(value) {
-        if (this.killed)
-            return;
-        if (!this.enabled)
-            return;
-        if (!this.filters.isEmpty && !this.filters.processChain(value).isOK)
-            return;
-        this.process = true;
-        this.value = value;
-        for (let i = 0; i < this.subs.length; i++)
-            this.subs[i].send(value);
-        this.process = false;
-        this.trash.length && this.clearTrash();
-    }
-    stream(values) {
-        if (this.killed)
-            return;
-        if (!this.enabled)
-            return;
-        for (let i = 0; i < values.length; i++)
-            this.next(values[i]);
-    }
-    clearTrash() {
-        const length = this.trash.length;
-        for (let i = 0; i < length; i++)
-            this.unSubscribe(this.trash[i]);
-        this.trash.length = 0;
-    }
-    unSubscribe(listener) {
-        if (this.killed)
-            return;
-        if (this.process && listener) {
-            this.trash.push(listener);
-            return;
-        }
-        this.subs && !(0, FunctionLibs_1.quickDeleteFromArray)(this.subs, listener);
-    }
-    destroy() {
-        if (this.killed)
-            return;
-        this.killed = true;
-        if (!this.process) {
-            this.value = null;
-            this.subs.length = 0;
-            return;
-        }
-        const timer = setInterval(() => {
-            if (this.process)
-                return;
-            clearInterval(timer);
-            this.value = null;
-            this.subs.length = 0;
-        }, 10);
-    }
-    unsubscribeAll() {
-        if (this.killed)
-            return;
-        this.subs.length = 0;
-    }
-    getValue() {
-        if (this.killed)
-            return undefined;
-        return this.value;
-    }
-    size() {
-        if (this.killed)
-            return 0;
-        return this.subs.length;
-    }
-    subscribe(observer, errorHandler) {
-        if (this.killed)
-            return undefined;
-        if (!this.isListener(observer))
-            return undefined;
-        const subscribeObject = new SubscribeObject_1.SubscribeObject(this, false);
-        this.addObserver(subscribeObject, observer, errorHandler);
-        return subscribeObject;
-    }
-    addObserver(subscribeObject, observer, errorHandler) {
-        subscribeObject.subscribe(observer, errorHandler);
-        this.subs.push(subscribeObject);
-    }
-    isListener(listener) {
-        if (this.killed)
-            return false;
-        return !!listener;
-    }
-    pipe() {
-        if (this.killed)
-            return undefined;
-        const subscribeObject = new SubscribeObject_1.SubscribeObject(this, true);
-        this.subs.push(subscribeObject);
-        return subscribeObject;
-    }
-    get isDestroyed() {
-        return this.killed;
-    }
-}
-exports.Observable = Observable;

package/src/outLib/OrderedObservable.d.ts

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

package/src/outLib/OrderedObservable.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderedObservable = void 0;
-const Observable_1 = require("./Observable");
-const FunctionLibs_1 = require("./FunctionLibs");
-const OrderedSubscribeObject_1 = require("./OrderedSubscribeObject");
-class OrderedObservable extends Observable_1.Observable {
-    sortDirection = FunctionLibs_1.sortAscending;
-    setAscendingSort() {
-        this.sortDirection = FunctionLibs_1.sortAscending;
-        return this.sortByOrder();
-    }
-    setDescendingSort() {
-        this.sortDirection = FunctionLibs_1.sortDescending;
-        return this.sortByOrder();
-    }
-    sortByOrder() {
-        if (this.killed)
-            return false;
-        this.subs.sort(this.sortDirection);
-        return true;
-    }
-    subscribe(listener, errorHandler) {
-        if (!this.isListener(listener))
-            return undefined;
-        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, false);
-        this.addObserver(subscribeObject, listener, errorHandler);
-        return subscribeObject;
-    }
-    pipe() {
-        if (this.killed)
-            return undefined;
-        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, true);
-        this.subs.push(subscribeObject);
-        return subscribeObject;
-    }
-    unSubscribe(listener) {
-        if (this.killed)
-            return;
-        if (this.process && listener) {
-            this.trash.push(listener);
-            return;
-        }
-        this.subs && !(0, FunctionLibs_1.deleteFromArray)(this.subs, listener);
-    }
-}
-exports.OrderedObservable = OrderedObservable;

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -1,10 +0,0 @@
-import { SubscribeObject } from "./SubscribeObject";
-import { IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISetObservableValue } from "./Types";
-import { OrderedObservable } from "./OrderedObservable";
-export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implements IOrderedSetup<T> {
-    constructor(observable: OrderedObservable<T> | IOrdered<T>, isPipe?: boolean);
-    get order(): number;
-    set order(value: number);
-    subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
-    setOnce(): IOrderedSubscribe<T>;
-}

package/src/outLib/OrderedSubscribeObject.js

@@ -1,29 +0,0 @@
-"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.observer ||
-            (this.observer && this.observer.isDestroyed)) {
-            this._order = undefined;
-            return;
-        }
-        this._order = value;
-        this.observer.sortByOrder();
-    }
-    subscribe(observer, errorHandler) {
-        super.subscribe(observer, errorHandler);
-        return this;
-    }
-    setOnce() {
-        return super.setOnce();
-    }
-}
-exports.OrderedSubscribeObject = OrderedSubscribeObject;

package/src/outLib/Pipe.d.ts

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

package/src/outLib/Pipe.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PipeSwitchCase = exports.Pipe = void 0;
-const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
-class Pipe {
-    chain = [];
-    flow = { isBreak: false, isUnsubscribe: false, isAvailable: false, payload: null };
-    push(callback) {
-        this.chain.push(callback);
-        return this;
-    }
-    setOnce() {
-        return this.push((data) => {
-            this.listener(data.payload);
-            data.isUnsubscribe = true;
-        });
-    }
-    unsubscribeBy(condition) {
-        return this.push((data) => {
-            data.isAvailable = true;
-            if (condition(data.payload))
-                data.isUnsubscribe = true;
-        });
-    }
-    refine(condition) {
-        return this.push((data) => condition(data.payload) && (data.isAvailable = true));
-    }
-    pushRefiners(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.refine(conditions[i]);
-        return this;
-    }
-    switch() {
-        return new PipeSwitchCase(this);
-    }
-    then(condition) {
-        return this.push((data) => {
-            data.payload = condition(data.payload);
-            data.isAvailable = true;
-        });
-    }
-    serialize() {
-        return this.push((data) => {
-            data.payload = JSON.stringify(data.payload);
-            data.isAvailable = true;
-        });
-    }
-    deserialize() {
-        return this.push((data) => {
-            data.payload = JSON.parse(data.payload);
-            data.isAvailable = true;
-        });
-    }
-    processChain(listener) {
-        const chain = this.chain;
-        const data = this.flow;
-        for (let i = 0; i < chain.length; i++) {
-            data.isUnsubscribe = false;
-            data.isAvailable = false;
-            chain[i](data);
-            if (data.isUnsubscribe)
-                return this.unsubscribe();
-            if (!data.isAvailable)
-                return;
-            if (data.isBreak)
-                break;
-        }
-        return listener(data.payload);
-    }
-}
-exports.Pipe = Pipe;
-class PipeSwitchCase extends AbstractSwitchCase_1.SwitchCase {
-    subscribe(listener, errorHandler) {
-        return this.pipe.subscribe(listener, errorHandler);
-    }
-}
-exports.PipeSwitchCase = PipeSwitchCase;

package/src/outLib/SubscribeObject.d.ts

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