evg_observable 1.0.10 → 1.0.11

package/README.md

@@ -47,5 +47,99 @@ observable$.destroy(); // all subscribers have automatically unsubscribed
 ```
 
 ## Observable pipe usage
+### pipe().setOnce()
 
-### 
+Observable will send a value to the subscriber only once, and the subscriber will unsubscribe.
+
+```ts
+import {Observable} from "evg_observable/src/outLib/Observables/Observable";
+
+const observable$ = new Observable('Some typed data (not only string)');
+const listener1 = (value: string) => console.log('listener1:',value);
+const listener2 = (value: string) => console.log('listener2:',value);
+
+const subscriber1 = observable$
+    .pipe()
+    .setOnce()
+    .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 - listener2: 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/Observables/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)
+Observable will send a value to the subscriber as long as the condition is negative, on the first positive result, the subscriber will unsubscribe.
+```ts
+import {Observable} from "evg_observable/src/outLib/Observables/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;
+
+const subscriber1 = observable$
+    .pipe()
+    .unsubscribeByPositive(() => 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 = true;
+observable$.next('Next3 typed data')
+// Print to console - listener2: Next3 typed data
+
+// subscriber1 is automatically unsubscribed when positive condition
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Light observable",
   "main": "index.js",
   "directories": {

package/src/Libraries/FunctionLibs.ts

@@ -1,9 +0,0 @@
-export function deleteFromArray<T>(arr: T[], component: T): boolean {
-    const index = arr.indexOf(component);
-    if (index === -1) return false;
-    const length = arr.length - 1;
-    for (let i = index; i < length;) arr[i++] = arr[i];
-    arr.length--;
-    return true;
-}
-

package/src/Libraries/Observables/Collector.ts

@@ -1,44 +0,0 @@
-import {ICollector, ISubscriptionLike} from "./Types";
-import {deleteFromArray} from "../FunctionLibs";
-
-export class Collector implements ICollector {
-    private list: ISubscriptionLike<any>[] = [];
-    private _isDestroyed = false;
-
-    collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void {
-        if(this._isDestroyed) return null;
-        for (let i = 0; i < subscriptionLikeList.length; i++) {
-            this.list.push(subscriptionLikeList[i]);
-        }
-    }
-
-    unsubscribe(subscriptionLike: ISubscriptionLike<any>): void {
-        if(this._isDestroyed) return null;
-        subscriptionLike && subscriptionLike.unsubscribe();
-        deleteFromArray(this.list, subscriptionLike);
-    }
-
-    unsubscribeAll(): void {
-        if(this._isDestroyed) return null;
-        const length = this.list.length;
-        for (let i = 0; i < length; i++) {
-            this.unsubscribe(this.list.pop());
-        }
-    }
-
-    size(): number {
-        if(this._isDestroyed) return 0;
-        return this.list.length;
-    }
-
-    destroy(): void {
-        this.unsubscribeAll();
-        this.list.length = 0;
-        this.list = <any>0;
-        this._isDestroyed = true;
-    }
-
-    get isDestroyed(): boolean {
-        return this._isDestroyed;
-    }
-}

package/src/Libraries/Observables/Observable.ts

@@ -1,222 +0,0 @@
-import {
-    ICallback,
-    IListener,
-    IObserver,
-    IOnceMarker,
-    ISetup,
-    ISubscribe,
-    ISubscribeObject,
-    ISubscriptionLike
-} from "./Types";
-import {deleteFromArray} from "../FunctionLibs";
-
-export class SubscribeObject<T> implements ISubscribeObject<T> {
-    protected observable: IObserver<T>;
-    protected listener: IListener<T>;
-    private isListenPaused = false;
-    private once: IOnceMarker = {isOnce: false, isFinished: false};
-    private unsubscribeByNegativeCondition: ICallback<any> = null;
-    private unsubscribeByPositiveCondition: ICallback<any> = null;
-    private emitByNegativeCondition: ICallback<any> = null;
-    private emitByPositiveCondition: ICallback<any> = null;
-    private emitMatchCondition: ICallback<any> = null;
-    protected _order = 0;
-
-    constructor(observable?: IObserver<T>, listener?: IListener<T>) {
-        this.observable = observable;
-        this.listener = listener;
-    }
-
-    subscribe(listener: IListener<T>): ISubscriptionLike<T> {
-        this.listener = listener;
-        return this;
-    }
-
-    public unsubscribe(): void {
-        if (!!this.observable) {
-            this.observable.unSubscribe(this);
-            this.observable = <any>0;
-            this.listener = <any>0;
-        }
-    }
-
-    send(value: T): void {
-        switch (true) {
-            case !this.observable:
-            case !this.listener:
-                this.unsubscribe();
-                return;
-            case this.isListenPaused:
-                return;
-            case this.once.isOnce:
-                this.once.isFinished = true;
-                this.listener(value);
-                this.unsubscribe();
-                break;
-            case !!this.unsubscribeByNegativeCondition:
-                if (!this.unsubscribeByNegativeCondition()) {
-                    this.unsubscribeByNegativeCondition = null;
-                    this.unsubscribe();
-                    return;
-                }
-                this.listener(value);
-                break;
-            case !!this.unsubscribeByPositiveCondition:
-                if (this.unsubscribeByPositiveCondition()) {
-                    this.unsubscribeByPositiveCondition = null;
-                    this.unsubscribe();
-                    return;
-                }
-                this.listener(value);
-                break;
-            case !!this.emitByNegativeCondition:
-                !this.emitByNegativeCondition() && this.listener(value);
-                break;
-            case !!this.emitByPositiveCondition:
-                this.emitByPositiveCondition() && this.listener(value);
-                break;
-            case !!this.emitMatchCondition:
-                (this.emitMatchCondition() === value) && this.listener(value);
-                break;
-            default:
-                this.listener(value);
-        }
-    }
-
-    setOnce(): ISubscribe<T> {
-        this.once.isOnce = true;
-        return this;
-    }
-
-    unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T> {
-        this.unsubscribeByNegativeCondition = condition;
-        return this
-    }
-
-    unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T> {
-        this.unsubscribeByPositiveCondition = condition;
-        return this;
-    }
-
-    emitByNegative(condition: ICallback<any>): ISubscribe<T> {
-        this.emitByNegativeCondition = condition;
-        return this;
-    }
-
-    emitByPositive(condition: ICallback<any>): ISubscribe<T> {
-        this.emitByPositiveCondition = condition;
-        return this;
-    }
-
-    emitMatch(condition: ICallback<any>): ISubscribe<T> {
-        this.emitMatchCondition = condition;
-        return this;
-    }
-
-    resume(): void {
-        this.isListenPaused = false;
-    }
-
-    pause(): void {
-        this.isListenPaused = true;
-    }
-
-    get order(): number {
-        return this._order;
-    }
-
-    set order(value: number) {
-        this._order = value;
-    }
-}
-
-export class Observable<T> implements IObserver<T> {
-    protected listeners: ISubscribeObject<T>[] = [];
-    private _isEnable: boolean = true;
-    protected _isDestroyed = false;
-    private isNextProcess = false;
-    private listenersForUnsubscribe: ISubscriptionLike<T>[] = [];
-
-    constructor(private value: T) {
-    }
-
-    disable(): void {
-        this._isEnable = false;
-    }
-
-    enable(): void {
-        this._isEnable = true;
-    }
-
-    get isEnable(): boolean {
-        return this._isEnable;
-    }
-
-    public next(value: T): void {
-        if (this._isDestroyed) return;
-        if (!this._isEnable) return;
-        this.value = value;
-        this.isNextProcess = true;
-        for (let i = 0; i < this.listeners.length; i++) this.listeners[i].send(value);
-        this.isNextProcess = false;
-        this.handleListenersForUnsubscribe();
-    }
-
-    private handleListenersForUnsubscribe(): void {
-        for (const listener of this.listenersForUnsubscribe) {
-            this.unSubscribe(listener);
-        }
-        this.listenersForUnsubscribe.length = 0;
-    }
-
-    public unSubscribe(listener: ISubscriptionLike<T>): void {
-        if (this._isDestroyed) return;
-        if (this.isNextProcess) {
-            this.listenersForUnsubscribe.push(listener);
-            return;
-        }
-        this.listeners &&
-        !deleteFromArray(this.listeners, listener);
-    }
-
-    public destroy(): void {
-        this.value = <any>0;
-        this.unsubscribeAll();
-        this.listeners = <any>0;
-        this._isDestroyed = true;
-    }
-
-    public unsubscribeAll(): void {
-        if (this._isDestroyed) return;
-        const length = this.listeners.length;
-        for (let i = 0; i < length; i++) (this.listeners.pop()).unsubscribe();
-    }
-
-    public getValue(): T {
-        if (this._isDestroyed) return undefined;
-        return this.value;
-    }
-
-    public size(): number {
-        if (this._isDestroyed) return 0;
-        return this.listeners.length;
-    }
-
-    public subscribe(listener: IListener<T>): ISubscriptionLike<T> {
-        if (this._isDestroyed) return undefined;
-        const subscribeObject = new SubscribeObject(this, listener);
-        this.listeners.push(subscribeObject);
-        return subscribeObject;
-    }
-
-    pipe(): ISetup<T> {
-        if (this._isDestroyed) return undefined;
-        const subscribeObject = new SubscribeObject(this);
-        this.listeners.push(subscribeObject);
-        return subscribeObject;
-    }
-
-    get isDestroyed(): boolean {
-        return this._isDestroyed;
-    }
-}

package/src/Libraries/Observables/OrderedObservable.ts

@@ -1,86 +0,0 @@
-import {Observable, SubscribeObject} from "./Observable";
-import {
-    ICallback,
-    IListener,
-    IObserver,
-    IOrdered,
-    IOrderedObservable,
-    IOrderedSetup,
-    IOrderedSubscribe,
-    IOrderedSubscriptionLike
-} from "./Types";
-
-export class OrderedSubscribeObject<T> extends SubscribeObject<T> {
-    constructor(observable: OrderedObservable<T> | IOrdered<T>, listener?: IListener<T>) {
-        super(<IObserver<T>>observable, listener);
-    }
-
-    get order(): number {
-        return this._order;
-    }
-
-    set order(value: number) {
-        if (!this.observable ||
-            (this.observable && this.observable.isDestroyed)) {
-            this._order = undefined;
-            return
-        }
-        this._order = value;
-        (<IOrderedObservable><any>this.observable).sortByOrder();
-    }
-
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T> {
-        this.listener = listener;
-        return this;
-    }
-
-    setOnce(): IOrderedSubscribe<T> {
-        return <any>super.setOnce();
-    }
-
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T> {
-        return <any>super.unsubscribeByNegative(condition);
-    }
-
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T> {
-        return <any>super.unsubscribeByPositive(condition);
-    }
-
-    emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T> {
-        return <any>super.emitByNegative(condition);
-    }
-
-    emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T> {
-        return <any>super.emitByPositive(condition);
-    }
-
-    emitMatch(condition: ICallback<any>): IOrderedSubscribe<T> {
-        return <any>super.emitMatch(condition);
-    }
-}
-
-export class OrderedObservable<T>
-    extends Observable<T> implements IOrdered<T> {
-    sortByOrder(): void {
-        if (this._isDestroyed) return undefined;
-        this.listeners.sort((a, b) => {
-            if (a.order > b.order) return 1;
-            if (a.order < b.order) return -1;
-            return 0;
-        });
-    }
-
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T> {
-        if (this._isDestroyed) return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this, listener);
-        this.listeners.push(subscribeObject);
-        return subscribeObject;
-    }
-
-    pipe(): IOrderedSetup<T> {
-        if (this._isDestroyed) return undefined;
-        const subscribeObject = new OrderedSubscribeObject(this);
-        this.listeners.push(subscribeObject);
-        return subscribeObject;
-    }
-}

package/src/Libraries/Observables/Types.ts

@@ -1,159 +0,0 @@
-export type ICallback<T> = (value?: T) => any;
-
-export type ISubscribe<T> = {
-    subscribe(listener: IListener<T>): ISubscriptionLike<T>;
-};
-
-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 IOnce<T> = {
-    setOnce(): ISubscribe<T>;
-};
-
-export type IOrderedOnce<T> = {
-    setOnce(): IOrderedSubscribe<T>;
-};
-
-export type ISetObservableValue = {
-    next(value: any): void;
-};
-
-export type ISubscriptionLike<T> = {
-    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 ISubscribeObject<T> =
-    ISubscriptionLike<T> &
-    IPause &
-    IOrder &
-    ISend<T> &
-    ISetup<T>;
-
-export type ISubscribeCounter = {
-    size(): number;
-};
-
-export type ISubscriber<T> =
-    {
-        getValue(): T,
-        isEnable: boolean
-    } &
-    ISubscribe<T>;
-
-export type IObserver<T> =
-    ISetObservableValue &
-    ISubscriber<T> &
-    IDestroy &
-    ISubscribeCounter &
-    IObservablePipe<T> &
-    {
-        unSubscribe(ISubscriptionLike): void,
-        unsubscribeAll(): void,
-        disable(): void,
-        enable(): void,
-    };
-
-export type IPause = {
-    pause(): void;
-    resume(): void;
-};
-
-export type IObservablePipe<T> = {
-    pipe(): ISetup<T>
-};
-
-export type ISend<T> = {
-    send(value: T): void;
-};
-
-export type IUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedUnsubscribeByNegative<T> = {
-    unsubscribeByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedUnsubscribeByPositive<T> = {
-    unsubscribeByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitByNegative<T> = {
-    emitByNegative(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitByPositive<T> = {
-    emitByPositive(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type IEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): ISubscribe<T>;
-};
-
-export type IOrderedEmitMatchCondition<T> = {
-    emitMatch(condition: ICallback<any>): IOrderedSubscribe<T>;
-};
-
-export type ICollector =
-    IDestroy &
-    ISubscribeCounter &
-    {
-        collect(...subscriptionLikeList: ISubscriptionLike<any>[]): void;
-        unsubscribe(subscriptionLike: ISubscriptionLike<any>): void;
-        unsubscribeAll(): void;
-    };
-
-export type IOrderedObservable = {
-    sortByOrder(): void;
-};
-
-export type IOrdered<T> = IObserver<T> & IOrderedObservable;
-
-export type IOrderedSubscriptionLike<T> = ISubscriptionLike<T> & IOrder;
-export type IOrderedSubscribe<T> = {
-    subscribe(listener: IListener<T>): IOrderedSubscriptionLike<T>;
-};