evg_observable 2.15.0 → 2.15.2

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "evg_observable",
-  "version": "2.15.0",
+  "version": "2.15.2",
   "description": "Alternative fast and light library version - observable.",
   "main": "src/outLib/index.js",
+  "types": "src/outLib/index.d.ts",
   "directories": {
     "test": "test"
   },

package/src/outLib/AbstractSwitchCase.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,32 @@
+"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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,41 @@
+"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;
+        const arr = this.arr;
+        for (let i = 0; i < arr.length; i++)
+            arr[i].unsubscribe();
+        arr.length = 0;
+    }
+    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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,69 @@
+"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 {
+            const len = chain.length;
+            for (let i = 0; i < len; 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

@@ -0,0 +1,6 @@
+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>(listenerGroup: ISubscribeGroup<T>): IListener<T>;

package/src/outLib/FunctionLibs.js

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

package/src/outLib/Observable.d.ts

@@ -0,0 +1,30 @@
+import { IAddFilter, IErrorCallback, IFilterSetup, IObserver, ISetup, IStream, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { SubscribeObject } from "./SubscribeObject";
+import { FilterCollection } from "./FilterCollection";
+export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilter<T> {
+    protected subs: ISubscribeObject<T>[];
+    protected enabled: boolean;
+    protected killed: boolean;
+    protected process: boolean;
+    protected trash: ISubscriptionLike[];
+    protected filters: FilterCollection<T>;
+    protected _value: T;
+    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

@@ -0,0 +1,137 @@
+"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 {
+    subs = [];
+    enabled = true;
+    killed = false;
+    process = false;
+    trash = [];
+    filters = new FilterCollection_1.FilterCollection();
+    _value;
+    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.subs.length)
+            return;
+        if (!this.filters.isEmpty && !this.filters.processChain(value).isOK)
+            return;
+        this.process = true;
+        this._value = value;
+        const subs = this.subs;
+        const len = subs.length;
+        for (let i = 0; i < len; i++)
+            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;
+        }
+        Promise.resolve().then(() => {
+            this._value = null;
+            this.subs.length = 0;
+        });
+    }
+    unsubscribeAll() {
+        if (this.killed)
+            return;
+        if (this.process) {
+            const subs = this.subs;
+            for (let i = 0; i < subs.length; i++)
+                this.trash.push(subs[i]);
+            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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,47 @@
+"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.quickDeleteFromArray)(this.subs, listener);
+    }
+}
+exports.OrderedObservable = OrderedObservable;

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,29 @@
+"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,80 @@
+"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;
+        const len = chain.length;
+        for (let i = 0; i < len; 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

@@ -0,0 +1,18 @@
+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);
+}