flinker 1.0.0 → 1.0.5

package/dist/RX.d.ts

@@ -0,0 +1,22 @@
+import { type RXAnyOperatorProtocol } from './RXOperator.js';
+import { type AnyRXObservable, type RXObservable, RXQueue } from './RXPublisher.js';
+export type RXObjectType = 'operator' | 'observable' | 'pipeline' | 'object';
+export interface RXObject {
+    type: RXObjectType;
+}
+export type RXAnySender = RXSender<any, any>;
+export interface RXSender<V, E> {
+    send(value: V, broadcast: boolean): void;
+    sendError(e: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+}
+export declare class RX {
+    static combine(...list: Array<AnyRXObservable | RXAnyOperatorProtocol>): RXObservable<any[], any>;
+    static from<V, E>(list: V[]): RXObservable<V, E>;
+    static queue<V, E>(): RXQueue<V, E>;
+    static waitUntilComplete<V, E>(list: AnyRXObservable[] | AnyRXObservable, result?: RXObservable<V, E>): RXObservable<V, E>;
+    static justComplete<V, E>(value?: V): RXObservable<V, E>;
+    static justError<V, E>(error: E): RXObservable<V, E>;
+    static delayedComplete<V, E>(ms: number, value?: V): RXObservable<V, E>;
+    static delayedError<V, E>(ms: number, error: E): RXObservable<V, E>;
+}

package/dist/RXObserver.d.ts

@@ -0,0 +1,33 @@
+import { type AnyRXObservable, type RXObservable } from './RXPublisher.js';
+export declare function observe<RXElement extends AnyRXObservable | undefined>(rx: RXElement): RXElement;
+export declare function observeFrom(rx: () => AnyRXObservable): void;
+export declare function observer<T>(component: (props: T) => React.JSX.Element): (props: T) => React.JSX.Element;
+type JSXSubscriberUID = number;
+export declare class JSXSubscriber {
+    static readonly empty: JSXSubscriber;
+    readonly uid: JSXSubscriberUID;
+    private readonly buildersSet;
+    private readonly unsubscribeColl;
+    renderCycle: number;
+    initialized: boolean;
+    readonly forceRenderFunc: (renderCycle: number) => void;
+    constructor(forceRenderFunc: (renderCycle: number) => void);
+    private _isDisposed;
+    get isDisposed(): boolean;
+    observe<V, E>(b: RXObservable<V, E>): void;
+    observeFrom(f: () => AnyRXObservable): void;
+    dispose(): void;
+    resurrect(): void;
+    render(renderCycle: number): boolean;
+}
+export declare class ObservableGlobalState {
+    static renderCycle: number;
+    static initializingJSXComponent: JSXSubscriber;
+    static debug: boolean;
+}
+export declare enum RenderQueueStatus {
+    IDLE = "IDLE",
+    PENDING = "PENDING",
+    RUNNING = "LOADING"
+}
+export {};

package/dist/RXOperator.d.ts

@@ -0,0 +1,133 @@
+import { type RXObservable } from './RXPublisher.js';
+import { type RXAnyPipeline, type RXPipeline } from './RXPipeline';
+import { type CompleteMethod, type ErrorMethod, type SubscribeMethod } from './RXSubscriber.js';
+import { type RXAnySender, type RXObject, type RXObjectType, type RXSender } from './RX.js';
+export interface RXOperatorProtocol<V, E> extends RXObject {
+    skipFirst(): RXOperatorProtocol<V, E>;
+    skipNullable(): RXOperatorProtocol<NonNullable<V>, E>;
+    removeDuplicates(defValue?: V): RXOperatorProtocol<V, E>;
+    debounce(ms: number): RXOperatorProtocol<V, E>;
+    map<T>(f: (v: V) => T): RXOperatorProtocol<T, E>;
+    flatMap<T>(f: (v: V) => RXObservable<T, E>): RXOperatorProtocol<T, E>;
+    forEach<T>(f: (v: V) => RXObservable<T, E>): RXOperatorProtocol<T, E>;
+    sequent<T>(f: (v: V) => RXObservable<T, E>): RXOperatorProtocol<T, E>;
+    parallel<T>(f: (v: V) => RXObservable<T, E>): RXOperatorProtocol<T, E>;
+    filter(predicate: (v: V) => boolean): RXOperatorProtocol<V, E>;
+    spread(): RXOperatorProtocol<ArrayElementTypeOf<V>, E>;
+    replaceError(replaceWith: (e: E) => V | null): RXOperatorProtocol<V, E>;
+    fork(): RXObservable<V, E>;
+    onReceive(f: (v: V) => void): ErrorMethod<E> & CompleteMethod & SubscribeMethod;
+    onError(f: (e: E) => void): CompleteMethod & SubscribeMethod;
+    onComplete(f: () => void): SubscribeMethod;
+}
+type ArrayElementTypeOf<T> = T extends Array<infer U> ? U : T;
+export type RXAnyOperator = RXOperator<any, any>;
+export type RXAnyOperatorProtocol = RXOperatorProtocol<any, any>;
+export declare class RXOperator<V, E> implements RXOperatorProtocol<V, E>, RXSender<V, E> {
+    protected pipeline: RXAnyPipeline;
+    protected child?: RXAnySender;
+    readonly type: RXObjectType;
+    constructor(pipeline: RXPipeline<V, E>);
+    protected _isComplete: boolean;
+    get isComplete(): boolean;
+    send(value: any, broadcast: boolean): void;
+    sendError(e: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+    skipFirst(): RXOperator<V, E>;
+    skipNullable(): RXOperator<NonNullable<V>, E>;
+    removeDuplicates(value?: V): RXOperator<V, E>;
+    debounce(ms: number): RXOperator<V, E>;
+    map<T>(f: (v: V) => T): RXOperator<T, E>;
+    flatMap<T>(f: (v: V) => RXObservable<T, E>): RXOperator<T, E>;
+    forEach<T>(f: (v: V) => RXObservable<T, E>): RXOperator<T, E>;
+    sequent<T>(f: (v: V) => RXObservable<T, E>): RXOperator<T, E>;
+    parallel<T>(f: (v: V) => RXObservable<T, E>): RXOperator<T, E>;
+    filter(predicate: (v: V) => boolean): RXOperator<V, E>;
+    spread(): RXOperator<ArrayElementTypeOf<V>, E>;
+    replaceError(replaceWith: (e: E) => V | null): RXOperator<V, E>;
+    private addChild;
+    fork(): RXObservable<V, E>;
+    onReceive(f: (v: V) => void): ErrorMethod<E> & CompleteMethod & SubscribeMethod;
+    onError(f: (e: E) => void): CompleteMethod & SubscribeMethod;
+    onComplete(f: () => void): SubscribeMethod;
+}
+export declare class RXMap<V, E> extends RXOperator<V, E> {
+    protected mapper: (value: any) => V;
+    constructor(pipe: RXAnyPipeline, mapper: (value: any) => V);
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXFlatMap<V, E> extends RXOperator<V, E> {
+    protected mapper: (value: any) => RXObservable<V, E>;
+    constructor(pipe: RXAnyPipeline, mapper: (value: any) => RXObservable<V, E>);
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXForEach<V, E> extends RXOperator<V, E> {
+    protected mapper: (value: any) => RXObservable<V, E>;
+    private readonly buffer;
+    private willComplete;
+    private willCompleteBroadcast;
+    constructor(pipe: RXAnyPipeline, mapper: (value: any) => RXObservable<V, E>);
+    send(value: any, broadcast: boolean): void;
+    sendError(error: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+    private curOp;
+    private processNext;
+}
+export declare class RXSequent<V, E> extends RXOperator<V, E> {
+    protected mapper: (value: any) => RXObservable<V, E>;
+    private readonly buffer;
+    private willComplete;
+    private willCompleteBroadcast;
+    constructor(pipe: RXAnyPipeline, mapper: (value: any) => RXObservable<V, E>);
+    send(value: any, broadcast: boolean): void;
+    sendError(error: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+    private curOp;
+    private processNext;
+}
+export declare class RXParallel<V, E> extends RXOperator<V, E> {
+    protected mapper: (value: any) => RXObservable<V, E>;
+    private willComplete;
+    private willCompleteBroadcast;
+    private activeOperations;
+    constructor(pipe: RXAnyPipeline, mapper: (value: any) => RXObservable<V, E>);
+    send(value: any, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+}
+export declare class RXFilter<V, E> extends RXOperator<V, E> {
+    protected predicate: (value: V) => boolean;
+    constructor(pipe: RXAnyPipeline, predicate: (value: V) => boolean);
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXSpread<V, E> extends RXOperator<V, E> {
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXSkipFirst<V, E> extends RXOperator<V, E> {
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXSkipNullable<V, E> extends RXOperator<V, E> {
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXRemoveDuplicates<V, E> extends RXOperator<V, E> {
+    private prevValue;
+    constructor(pipe: RXAnyPipeline, value?: V);
+    send(value: any, broadcast: boolean): void;
+}
+export declare class RXDebounce<V, E> extends RXOperator<V, E> {
+    readonly ms: number;
+    constructor(pipe: RXAnyPipeline, ms: number);
+    private readonly buffer;
+    private willComplete;
+    private willCompleteBroadcast;
+    private timeoutId;
+    private startTimer;
+    send(value: any, broadcast: boolean): void;
+    sendError(error: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+}
+export declare class RXReplaceError<V, E> extends RXOperator<V, E> {
+    readonly replaceWith: (e: E) => V | null;
+    constructor(pipe: RXAnyPipeline, replaceWith: (e: E) => V | null);
+    sendError(e: E, broadcast: boolean): void;
+}
+export {};

package/dist/RXPipeline.d.ts

@@ -0,0 +1,14 @@
+import { type RXPublisher } from './RXPublisher.js';
+import { RXOperator, type RXOperatorProtocol } from './RXOperator.js';
+import { type RXObject, type RXObjectType, type RXSender } from './RX.js';
+export type RXAnyPipeline = RXPipeline<any, any>;
+export declare class RXPipeline<V, E> implements RXSender<V, E>, RXObject {
+    readonly type: RXObjectType;
+    readonly dispatcher: RXPublisher<V, E>;
+    readonly child: RXOperator<V, E>;
+    get asOperator(): RXOperatorProtocol<V, E>;
+    constructor(dispatcher: RXPublisher<V, E>);
+    send(value: any, broadcast: boolean): void;
+    sendError(e: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+}

package/dist/RXPublisher.d.ts

@@ -0,0 +1,153 @@
+import { type RXAnyOperatorProtocol, type RXOperatorProtocol } from './RXOperator.js';
+import { type RXAnyPipeline } from './RXPipeline';
+import { type RXObject, type RXObjectType } from './RX';
+export type AnyRXObservable = RXObservable<any, any>;
+export interface RXObservable<V, E> extends RXObject {
+    suid: RXPublisherUID;
+    isComplete: boolean;
+    pipe(): RXOperatorProtocol<V, E>;
+}
+export type RXPublisherUID = number;
+export type RXAnyPublisher = RXPublisher<any, any>;
+export declare class RXPublisher<V, E> implements RXObservable<V, E> {
+    readonly suid: RXPublisherUID;
+    readonly type: RXObjectType;
+    protected readonly pipelines: RXAnyPipeline[];
+    constructor();
+    get volume(): number;
+    get asObservable(): RXObservable<V, E>;
+    protected _isComplete: boolean;
+    get isComplete(): boolean;
+    pipe(): RXOperatorProtocol<V, E>;
+    didSubscribe(p: RXAnyPipeline): void;
+    private readonly pendingUnsubscribePipes;
+    didUnsubscribe(p: RXAnyPipeline): void;
+    private isSending;
+    protected send(value: V): void;
+    protected sendError(e: E): void;
+    protected sendComplete(): void;
+    private runPendingOperations;
+}
+export declare class RXJustComplete<V, E> extends RXPublisher<V, E> {
+    readonly value?: V;
+    constructor(value?: V);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXJustError<V, E> extends RXPublisher<V, E> {
+    readonly error: E;
+    constructor(error: E);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXDelayedComplete<V, E> extends RXPublisher<V, E> {
+    readonly value?: V;
+    constructor(ms: number, value?: V);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXDelayedError<V, E> extends RXPublisher<V, E> {
+    readonly error: E;
+    constructor(ms: number, error: E);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXEmitter<V, E> extends RXPublisher<V, E> {
+    private _hasValue;
+    private _value;
+    get value(): V | undefined;
+    private hasError;
+    private _err;
+    get err(): E | undefined;
+    constructor();
+    send(value: V): void;
+    sendError(e: E): void;
+    sendComplete(): void;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXSubject<V, E> extends RXPublisher<V, E> {
+    private _value;
+    get value(): V;
+    private _hasError;
+    private _err;
+    get err(): E | undefined;
+    constructor(value: V);
+    send(value: V): void;
+    resend(): void;
+    sendError(e: E): void;
+    sendComplete(): void;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXBuffer<V, E> extends RXPublisher<V, E> {
+    private readonly values;
+    private readonly errors;
+    private readonly isError;
+    send(value: V): void;
+    sendError(e: E): void;
+    sendComplete(): void;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXOperation<V, E> extends RXPublisher<V, E> {
+    private _value;
+    get value(): V | undefined;
+    private _hasError;
+    private _err;
+    get err(): E | undefined;
+    success(value: V): void;
+    fail(e: E): void;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXCombine extends RXPublisher<any[], any> {
+    private readonly _values;
+    get values(): any[];
+    private _hasError;
+    private _err;
+    get err(): any | undefined;
+    constructor(list: Array<AnyRXObservable | RXAnyOperatorProtocol>);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXFrom<V, E> extends RXPublisher<V, E> {
+    readonly values: V[];
+    constructor(list: V[]);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXWaitUntilComplete<V, E> extends RXPublisher<V, E> {
+    private _value;
+    get value(): V | undefined;
+    private readonly _resultPublisher;
+    private _hasError;
+    private _err;
+    get err(): any | undefined;
+    constructor(list: AnyRXObservable[] | AnyRXObservable, resultPublisher?: RXObservable<V, E>);
+    private subscribeToResultPublisher;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXObservableEntity<V> extends RXPublisher<V, any> {
+    protected mutated(): void;
+    protected send(value: any): void;
+    protected dispose(): void;
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export declare class RXObservableValue<V> extends RXPublisher<V, any> {
+    private _value;
+    get value(): V;
+    set value(value: V);
+    constructor(value: V);
+    didSubscribe(p: RXAnyPipeline): void;
+}
+export type RXAnyQueueOperator = RXQueueOperator<any, any>;
+export declare class RXQueueOperator<V, E> {
+    protected readonly op: RXOperation<any, E>;
+    protected child?: RXQueueOperator<V, E>;
+    protected inProgress: boolean;
+    protected value: V | undefined;
+    constructor(op: RXOperation<any, E>);
+    protected send(value: any): void;
+    next<T>(f: (v: V) => RXObservable<T, E>): RXQueueOperator<T, E>;
+    private addChild;
+    complete(): RXObservable<V, E>;
+}
+export declare class RXQueue<V, E> extends RXQueueOperator<void, E> {
+    constructor();
+    get asObservable(): RXObservable<V, E>;
+    get isComplete(): boolean;
+    next<T>(f: () => RXObservable<T, E>): RXQueueOperator<T, E>;
+    success(v: V): void;
+    fail(e: E): void;
+}

package/dist/RXSubscriber.d.ts

@@ -0,0 +1,30 @@
+import type { RXSender } from './RX.ts';
+import { type RXAnyPipeline } from './RXPipeline.js';
+export interface ErrorMethod<E> {
+    onError(callback: (e: E) => void): CompleteMethod & SubscribeMethod;
+}
+export interface CompleteMethod {
+    onComplete(callback: () => void): SubscribeMethod;
+}
+export interface SubscribeMethod {
+    subscribe(): () => void;
+}
+export type RXAnySubscriber = RXSubscriber<any, any>;
+export declare class RXSubscriber<V, E> implements RXSender<V, E> {
+    private onReceiveCallback?;
+    private onErrorCallback?;
+    private onCompleteCallback?;
+    readonly pipeline: RXAnyPipeline;
+    constructor(pipeline: RXAnyPipeline);
+    private _isComplete;
+    get isComplete(): boolean;
+    send(value: V, broadcast: boolean): void;
+    sendError(e: E, broadcast: boolean): void;
+    sendComplete(broadcast: boolean): void;
+    onReceive(f: (v: any) => void): ErrorMethod<E> & CompleteMethod & SubscribeMethod;
+    onError(f: (e: E) => void): CompleteMethod & SubscribeMethod;
+    onComplete(f: () => void): SubscribeMethod;
+    private isSubscribed;
+    subscribe(): () => void;
+    unsubscribe(): void;
+}

package/dist/cjs/RX.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RX = void 0;
+var RXPublisher_js_1 = require("./RXPublisher.js");
+var RX = /** @class */ (function () {
+    function RX() {
+    }
+    //--------------------------------------
+    //  STATIC METHODS
+    //--------------------------------------
+    RX.combine = function () {
+        var list = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            list[_i] = arguments[_i];
+        }
+        return new RXPublisher_js_1.RXCombine(list).asObservable;
+    };
+    RX.from = function (list) {
+        return new RXPublisher_js_1.RXFrom(list).asObservable;
+    };
+    RX.queue = function () {
+        return new RXPublisher_js_1.RXQueue();
+    };
+    RX.waitUntilComplete = function (list, result) {
+        return new RXPublisher_js_1.RXWaitUntilComplete(list, result).asObservable;
+    };
+    RX.justComplete = function (value) {
+        return new RXPublisher_js_1.RXJustComplete(value).asObservable;
+    };
+    RX.justError = function (error) {
+        return new RXPublisher_js_1.RXJustError(error).asObservable;
+    };
+    RX.delayedComplete = function (ms, value) {
+        return new RXPublisher_js_1.RXDelayedComplete(ms, value).asObservable;
+    };
+    RX.delayedError = function (ms, error) {
+        return new RXPublisher_js_1.RXDelayedError(ms, error).asObservable;
+    };
+    return RX;
+}());
+exports.RX = RX;

package/dist/cjs/RXObserver.js

@@ -0,0 +1,255 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderQueueStatus = exports.ObservableGlobalState = exports.JSXSubscriber = void 0;
+exports.observe = observe;
+exports.observeFrom = observeFrom;
+exports.observer = observer;
+var react_1 = require("react");
+var __DEV__ = false;
+/*
+*
+*
+* GLOBAL OBSERVE METHODS
+*
+*
+* */
+function observe(rx) {
+    if (rx) {
+        var jsxSubscriber = ObservableGlobalState.initializingJSXComponent;
+        if (jsxSubscriber !== JSXSubscriber.empty) {
+            logInfo('observe(' + rx.constructor.name + '), subscriber uid =', jsxSubscriber.uid);
+            jsxSubscriber.observe(rx);
+        }
+        else {
+            logWarn('observe(' + rx.constructor.name + ') is failed: JSX Function Component has not "observer" wrapper!');
+        }
+    }
+    return rx;
+}
+function observeFrom(rx) {
+    if (rx) {
+        var jsxSubscriber = ObservableGlobalState.initializingJSXComponent;
+        if (jsxSubscriber !== JSXSubscriber.empty) {
+            logInfo('observeFunc(' + rx.constructor.name + '), subscriber uid =', jsxSubscriber.uid);
+            jsxSubscriber.observeFrom(rx);
+        }
+        else {
+            logWarn('observeFunc(' + rx.constructor.name + ') is failed: JSX Function Component has not "observer" wrapper!');
+        }
+    }
+}
+function observer(component) {
+    return function (props) {
+        var subscriberRef = (0, react_1.useRef)(JSXSubscriber.empty);
+        var _a = (0, react_1.useState)(ObservableGlobalState.renderCycle), forceRender = _a[1];
+        if (subscriberRef.current === JSXSubscriber.empty) {
+            subscriberRef.current = new JSXSubscriber(function (renderCycle) {
+                forceRender(renderCycle);
+            });
+        }
+        if (__DEV__) {
+            (0, react_1.useLayoutEffect)(function () {
+                if (ObservableGlobalState.debug)
+                    logInfo('Registering of unmounting [' + subscriberRef.current.uid + ']');
+                if (subscriberRef.current.isDisposed) {
+                    if (ObservableGlobalState.debug)
+                        logInfo('Disposed Subscriber [' + subscriberRef.current.uid + '] is resurrected');
+                    subscriberRef.current.resurrect();
+                }
+                return function () {
+                    if (ObservableGlobalState.debug)
+                        logInfo('Subscriber [' + subscriberRef.current.uid + '] is unmounted and disposed');
+                    subscriberRef.current.dispose();
+                };
+            }, []);
+        }
+        else {
+            (0, react_1.useLayoutEffect)(function () { return function () { subscriberRef.current.dispose(); }; }, []);
+        }
+        var parentGlobalComponent = ObservableGlobalState.initializingJSXComponent;
+        ObservableGlobalState.initializingJSXComponent = subscriberRef.current;
+        //initializing begin
+        subscriberRef.current.renderCycle = ObservableGlobalState.renderCycle;
+        var renderedComponent = component(props);
+        subscriberRef.current.initialized = true;
+        //initializing end
+        ObservableGlobalState.initializingJSXComponent = parentGlobalComponent;
+        return renderedComponent;
+    };
+}
+var suid = (function () { var value = 0; return function () { return value++; }; })();
+var JSXSubscriber = /** @class */ (function () {
+    function JSXSubscriber(forceRenderFunc) {
+        this.buildersSet = new Set();
+        this.unsubscribeColl = Array();
+        this.renderCycle = -1;
+        this.initialized = false;
+        this._isDisposed = false;
+        this.uid = suid();
+        this.forceRenderFunc = forceRenderFunc;
+    }
+    Object.defineProperty(JSXSubscriber.prototype, "isDisposed", {
+        get: function () {
+            return this._isDisposed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    JSXSubscriber.prototype.observe = function (b) {
+        var _this = this;
+        if (b.isComplete || this.buildersSet.has(b.suid))
+            return;
+        this.buildersSet.add(b.suid);
+        this.unsubscribeColl.push(b.pipe()
+            .onReceive(function () {
+            RenderQueue.self.add(_this);
+        })
+            .subscribe());
+    };
+    JSXSubscriber.prototype.observeFrom = function (f) {
+        var _this = this;
+        if (this.initialized)
+            return;
+        this.unsubscribeColl.push(f().pipe()
+            .skipFirst()
+            .onReceive(function () {
+            RenderQueue.self.add(_this);
+        })
+            .subscribe());
+    };
+    JSXSubscriber.prototype.dispose = function () {
+        this._isDisposed = true;
+        if (!__DEV__)
+            this.unsubscribeColl.forEach(function (f) { f(); });
+    };
+    JSXSubscriber.prototype.resurrect = function () {
+        this._isDisposed = false;
+    };
+    JSXSubscriber.prototype.render = function (renderCycle) {
+        if (this.isDisposed || this.renderCycle === renderCycle) {
+            return false;
+        }
+        else {
+            this.renderCycle = renderCycle;
+            logInfo('----::forceRenderFunc');
+            this.forceRenderFunc(this.renderCycle);
+            return true;
+        }
+    };
+    JSXSubscriber.empty = new JSXSubscriber(function () { });
+    return JSXSubscriber;
+}());
+exports.JSXSubscriber = JSXSubscriber;
+//--------------------------------------
+//  GlobalState
+//--------------------------------------
+var ObservableGlobalState = /** @class */ (function () {
+    function ObservableGlobalState() {
+    }
+    ObservableGlobalState.renderCycle = 0;
+    ObservableGlobalState.initializingJSXComponent = JSXSubscriber.empty;
+    ObservableGlobalState.debug = false;
+    return ObservableGlobalState;
+}());
+exports.ObservableGlobalState = ObservableGlobalState;
+//--------------------------------------
+//  RenderQueue
+//--------------------------------------
+var RenderQueueStatus;
+(function (RenderQueueStatus) {
+    RenderQueueStatus["IDLE"] = "IDLE";
+    RenderQueueStatus["PENDING"] = "PENDING";
+    RenderQueueStatus["RUNNING"] = "LOADING";
+})(RenderQueueStatus || (exports.RenderQueueStatus = RenderQueueStatus = {}));
+var RenderQueue = /** @class */ (function () {
+    function RenderQueue() {
+        this.temp = Array();
+        this.queue = new Set();
+        this.status = RenderQueueStatus.IDLE;
+        this.INFINITE_LOOP_LIMIT = 20;
+        this.infiniteLoopDetected = false;
+        this.loopRenderings = 0;
+    }
+    RenderQueue.prototype.add = function (s) {
+        var _this = this;
+        if (this.infiniteLoopDetected)
+            return;
+        if (this.status === RenderQueueStatus.RUNNING) {
+            this.temp.push(s);
+        }
+        else {
+            this.queue.add(s);
+            if (this.status === RenderQueueStatus.IDLE) {
+                this.status = RenderQueueStatus.PENDING;
+                setTimeout(function () {
+                    _this.render();
+                }, 0);
+            }
+        }
+    };
+    RenderQueue.prototype.render = function () {
+        var _this = this;
+        logInfo('RenderQueue:render: begin, cycle:', ObservableGlobalState.renderCycle);
+        this.status = RenderQueueStatus.RUNNING;
+        ObservableGlobalState.renderCycle++;
+        var renderedComponentsCount = 0;
+        Array.from(this.queue)
+            .sort(function (s1, s2) { return s1.uid - s2.uid; })
+            .forEach(function (subscriber) {
+            subscriber.render(ObservableGlobalState.renderCycle) && renderedComponentsCount++;
+        });
+        this.queue.clear();
+        this.status = RenderQueueStatus.IDLE;
+        if (this.temp.length > 0) {
+            this.loopRenderings++;
+            if (this.loopRenderings > 2) {
+                logWarn.apply(void 0, __spreadArray(__spreadArray(['Sending value from publisher while jsx-component is rendering may cause an infinite loop. Loop renderings:', this.loopRenderings,
+                    '. Most active publishers: ['], this.temp.map(function (ob) { return ob.constructor.name; }), false), [']'], false));
+            }
+            if (this.loopRenderings < this.INFINITE_LOOP_LIMIT) {
+                this.temp.forEach(function (publisherUID) {
+                    _this.add(publisherUID);
+                });
+                this.temp.length = 0;
+            }
+            else {
+                this.infiniteLoopDetected = true;
+                logWarn('--Infinite Loop! The possible reason: An executed jsx-component X invoked new rendering of a jsx-component, ' +
+                    'that caused mutation in publisher, that trigger again force render of X');
+            }
+        }
+        else {
+            this.loopRenderings = 0;
+        }
+        logInfo('RenderQueue:render: end, renderedComponentsCount:', renderedComponentsCount);
+    };
+    RenderQueue.self = new RenderQueue();
+    return RenderQueue;
+}());
+//--------------------------------------
+//  logging
+//--------------------------------------
+var logInfo = function () {
+    var msg = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        msg[_i] = arguments[_i];
+    }
+    if (ObservableGlobalState.debug)
+        console.log.apply(console, msg);
+};
+var logWarn = function () {
+    var msg = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        msg[_i] = arguments[_i];
+    }
+    console.warn.apply(console, msg);
+};