evg_observable 1.0.10 → 1.0.11

package/src/Libraries/TickGenerator.ts

@@ -1,178 +0,0 @@
-import {Observable} from "./Observables/Observable";
-import {cb_function, delay_ms, delay_second, ITick, ITickListener} from "./Types";
-import {ISubscriptionLike} from "./Observables/Types";
-
-let listeners: ITickListener[] = [];
-const tickDelay = 10;
-let tickIndex = <any>0,
-    secondFPSIndex = <any>0,
-    optimizeCounter = 0,
-    optimizeNumber = 1000,
-    tick10$ = new Observable(<any>0),
-    tick100$ = new Observable(<any>0),
-    secondFPS$ = new Observable(<any>0),
-    tick1000$ = new Observable(<any>0);
-
-class TickGenerator implements ITick {
-    private counter100 = 0;
-    private counter1000 = 0;
-    private isDestroyProcessed = false;
-    private _isDestroyed = false;
-
-    constructor() {
-        this.init();
-    }
-
-    private init(): void {
-        if (!secondFPSIndex) {
-            secondFPSIndex = setInterval(() => secondFPS$.next(-1), 1000);
-        }
-        if (!tickIndex) {
-            tickIndex = setInterval(() => {
-                this.counter100 += 10;
-                if (this.counter100 >= 100) this.counter100 = 0;
-
-                this.counter1000 += 10;
-                if (this.counter1000 >= 1000) this.counter1000 = 0;
-
-                tick10$.next(10);
-                if (!this.counter100) tick100$.next(100);
-                if (!this.counter1000) tick1000$.next(1000);
-
-                this.handleTimeOutListeners();
-            }, tickDelay);
-        }
-    }
-
-    executeSecondInterval(cb: cb_function, time: delay_second): ISubscriptionLike<any> {
-        const number = time;
-        return tick1000$.subscribe(() => {
-            if (time > 0) time--;
-
-            if (!time) {
-                cb();
-                time = number;
-            }
-        });
-    }
-
-    execute100MsInterval(cb: cb_function, time: delay_second): ISubscriptionLike<any> {
-        const number = time;
-        return tick100$.subscribe(() => {
-            if (time > 0) time--;
-
-            if (!time) {
-                cb();
-                time = number;
-            }
-        });
-    }
-
-    private handleTimeOutListeners(): void {
-        let isNeedToOptimize = false;
-        for (let i = 0; i < listeners.length; i++) {
-            const listener = listeners[i];
-            if (!listener) {
-                continue;
-            }
-            if (listener.isDestroy) {
-                listeners[i] = <any>0;
-                isNeedToOptimize = true;
-            } else {
-                if (listener.counter >= listener.delay) {
-                    listener.callback();
-                    listeners[i] = <any>0;
-                    isNeedToOptimize = true;
-                } else {
-                    listener.counter += tickDelay;
-                }
-            }
-        }
-        this.optimizeKeys(isNeedToOptimize);
-    }
-
-    private optimizeKeys(isNeedToOptimize: boolean): void {
-        if (!isNeedToOptimize) return;
-
-        optimizeCounter++;
-        if (optimizeCounter < optimizeNumber) return;
-
-        optimizeCounter = 0;
-        const tmpListeners: ITickListener[] = [];
-
-        const length = listeners.length;
-        for (let i = 0; i < length; i++) if (listeners[i]) tmpListeners.push(listeners[i]);
-
-        listeners.length = 0;
-        listeners = tmpListeners;
-        tmpListeners.length = 0;
-    }
-
-    get isDestroyed(): boolean {
-        return this._isDestroyed;
-    }
-
-    get tick10$(): Observable<any> {
-        return tick10$;
-    }
-
-    get tick100$(): Observable<any> {
-        return tick100$;
-    }
-
-    get tick1000$(): Observable<any> {
-        return tick1000$;
-    }
-
-    get secondFPS$(): Observable<any> {
-        return secondFPS$;
-    }
-
-    executeTimeout(cb: cb_function, time: delay_ms): ITickListener {
-        const listener: ITickListener = {
-            counter: 0,
-            delay: time,
-            callback: cb,
-            isDestroy: false
-        };
-        listeners.push(listener);
-        return listener;
-    }
-
-    clearTimeout(id: ITickListener): void {
-        if (!id) return;
-
-        id.isDestroy = true;
-        id.callback = () => console.log('listener has been destroyed');
-    }
-
-    destroy(): void {
-        if (this.isDestroyProcessed) return;
-        this.isDestroyProcessed = true;
-
-        this.counter100 = 0;
-        this.counter1000 = 0;
-        clearInterval(tickIndex);
-        clearInterval(secondFPSIndex);
-        tickIndex = <any>0;
-        secondFPSIndex = <any>0;
-
-        this.resetListeners(tick10$);
-        this.resetListeners(tick100$);
-        this.resetListeners(tick1000$);
-        this.resetListeners(secondFPS$);
-
-        tick10$ = <any>0;
-        tick100$ = <any>0;
-        tick1000$ = <any>0;
-        secondFPS$ = <any>0;
-
-        this._isDestroyed = true;
-    }
-
-    private resetListeners(observable: Observable<any>): void {
-        if (observable) observable.unsubscribeAll();
-    }
-}
-
-export const tickGenerator = new TickGenerator();

package/src/Libraries/Types.ts

@@ -1,27 +0,0 @@
-import {Observable} from "./Observables/Observable";
-import {ISubscriptionLike} from "./Observables/Types";
-
-export type IDestroyed = {
-    isDestroyed: boolean;
-};
-
-export type delay_ms = number;
-export type delay_second = number;
-export type cb_function = () => void;
-export type ITickListener = {
-    counter: number;
-    delay: delay_ms;
-    callback: cb_function;
-    isDestroy: boolean;
-};
-export type ITick = {
-    tick10$: Observable<any>;
-    tick100$: Observable<any>;
-    tick1000$: Observable<any>;
-    secondFPS$: Observable<any>;
-    executeTimeout(cb: cb_function, time: delay_ms): ITickListener;
-    execute100MsInterval(cb: cb_function, time: number): ISubscriptionLike<number>;
-    executeSecondInterval(cb: cb_function, time: delay_second): ISubscriptionLike<number>;
-    clearTimeout(id: ITickListener): void;
-    destroy(): void;
-} & IDestroyed;

package/test/Collector.unit.test.ts

@@ -1,244 +0,0 @@
-import {suite, test} from '@testdeck/mocha';
-import * as _chai from 'chai';
-import {expect} from 'chai';
-import {ICollector} from "../src/Libraries/Observables/Types";
-import {Collector} from "../src/Libraries/Observables/Collector";
-import {Observable} from "../src/Libraries/Observables/Observable";
-
-_chai.should();
-_chai.expect;
-
-@suite
-class CollectorUnitTest {
-    private COLLECTOR: ICollector;
-
-    before() {
-        this.COLLECTOR = new Collector();
-    }
-
-    @test 'collector is created'() {
-        expect(this.COLLECTOR.size()).to.be.eql(0);
-    }
-
-    @test 'collector collect one subscriber'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-    }
-
-    @test 'collector collect two subscribers'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        this.COLLECTOR.collect(observable$.subscribe(value => value));
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-    }
-
-    @test 'collector collect three subscribers'() {
-        const observable$ = new Observable(0);
-        this.COLLECTOR.collect(
-            observable$.subscribe(value => value),
-            observable$.subscribe(value => value),
-            observable$.subscribe(value => value),
-        );
-        expect(this.COLLECTOR.size()).to.be.equal(3);
-    }
-
-    @test 'collector collect ten subscribers'() {
-        const observable$ = new Observable(0);
-        for (let i = 0; i < 10; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-    }
-
-    @test 'collector collect zero subscribers'() {
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and unsubscribe'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.unsubscribe(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect zero subscribers and unsubscribe'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        this.COLLECTOR.unsubscribe(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect((<any>subscriptionLike).observable).to.be.equal(0);
-    }
-
-    @test 'collector collect zero subscribers and unsubscribeAll'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(!!(<any>subscriptionLike).observable).to.be.equal(true);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe one'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe two'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        this.COLLECTOR.unsubscribe(subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect two subscribers and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe one'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        expect(this.COLLECTOR.size()).to.be.equal(9);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe two'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        this.COLLECTOR.collect(subscriptionLike2);
-        for (let i = 0; i < 8; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribe(subscriptionLike1);
-        this.COLLECTOR.unsubscribe(subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(8);
-    }
-
-    @test 'collector collect ten subscribers and unsubscribe all'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        this.COLLECTOR.collect(subscriptionLike2);
-        for (let i = 0; i < 8; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.unsubscribeAll();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-    }
-
-    @test 'collector collect one subscriber and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike);
-        expect(this.COLLECTOR.size()).to.be.equal(1);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect two subscribers and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        const subscriptionLike2 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1, subscriptionLike2);
-        expect(this.COLLECTOR.size()).to.be.equal(2);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect ten subscribers and destroy'() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-    }
-
-    @test 'collector collect ten subscribers, destroy and collect '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.collect()).to.be.equal(null);
-    }
-
-    @test 'collector collect ten subscribers, destroy and unsubscribe '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.unsubscribe(subscriptionLike1)).to.be.equal(null);
-    }
-
-    @test 'collector collect ten subscribers, destroy and unsubscribeAll '() {
-        const observable$ = new Observable(0);
-        const subscriptionLike1 = observable$.subscribe(value => value);
-        this.COLLECTOR.collect(subscriptionLike1);
-        for (let i = 0; i < 9; i++) {
-            this.COLLECTOR.collect(observable$.subscribe(value => value));
-        }
-        expect(this.COLLECTOR.size()).to.be.equal(10);
-        this.COLLECTOR.destroy();
-        expect(this.COLLECTOR.size()).to.be.equal(0);
-        expect(this.COLLECTOR.isDestroyed).to.be.equal(true);
-        expect(this.COLLECTOR.unsubscribeAll()).to.be.equal(null);
-    }
-}

package/test/FunctionLib.unit.test.ts

@@ -1,86 +0,0 @@
-import {suite, test} from '@testdeck/mocha';
-import * as _chai from 'chai';
-import {expect} from 'chai';
-import {deleteFromArray} from "../src/Libraries/FunctionLibs";
-
-_chai.should();
-_chai.expect;
-
-@suite
-class FunctionLibUnitTest {
-    private deleteFromArray: <T>(arr: T[], component: T) => boolean;
-
-    before() {
-        this.deleteFromArray = deleteFromArray;
-    }
-
-    @test 'deleteFromArray: 1 from arr empty'() {
-        expect(this.deleteFromArray([], 1)).to.be.equal(false);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1]'() {
-        const arr = [1];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 2]'() {
-        const arr = [1, 2];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([2]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 2]'() {
-        const arr = [1, 2];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([2, 3]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 3]);
-    }
-
-    @test 'deleteFromArray: 3 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 3)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 2]);
-    }
-
-    @test 'deleteFromArray: 4 from arr [1, 2, 3]'() {
-        const arr = [1, 2, 3];
-        expect(this.deleteFromArray(arr, 4)).to.be.equal(false);
-        expect(arr).to.be.eql([1, 2, 3]);
-    }
-
-    @test 'deleteFromArray: 1 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 1)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 2, 3]);
-    }
-
-    @test 'deleteFromArray: 2 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 2)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 1, 3]);
-    }
-
-    @test 'deleteFromArray: 3 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 3)).to.be.equal(true);
-        expect(arr).to.be.eql([1, 1, 2]);
-    }
-
-    @test 'deleteFromArray: 4 from arr [1, 1, 2, 3]'() {
-        const arr = [1, 1, 2, 3];
-        expect(this.deleteFromArray(arr, 4)).to.be.equal(false);
-        expect(arr).to.be.eql([1, 1, 2, 3]);
-    }
-}