flinker 1.0.0 → 1.0.5

package/dist/cjs/RXSubscriber.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RXSubscriber = void 0;
+var RXSubscriber = /** @class */ (function () {
+    function RXSubscriber(pipeline) {
+        this._isComplete = false;
+        this.isSubscribed = false;
+        this.pipeline = pipeline;
+    }
+    Object.defineProperty(RXSubscriber.prototype, "isComplete", {
+        get: function () { return this._isComplete; },
+        enumerable: false,
+        configurable: true
+    });
+    RXSubscriber.prototype.send = function (value, broadcast) {
+        var _a;
+        if (!this._isComplete) {
+            (_a = this.onReceiveCallback) === null || _a === void 0 ? void 0 : _a.call(this, value);
+        }
+    };
+    RXSubscriber.prototype.sendError = function (e, broadcast) {
+        var _a;
+        if (!this._isComplete) {
+            (_a = this.onErrorCallback) === null || _a === void 0 ? void 0 : _a.call(this, e);
+        }
+    };
+    RXSubscriber.prototype.sendComplete = function (broadcast) {
+        var _a;
+        if (!this._isComplete) {
+            this._isComplete = true;
+            (_a = this.onCompleteCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.unsubscribe();
+        }
+    };
+    RXSubscriber.prototype.onReceive = function (f) {
+        if (this.isComplete)
+            throw new Error('RXSubscriber is complete: It can update onReceiveCallback');
+        else if (this.isSubscribed)
+            throw new Error('RXSubscriber can not update onReceiveCallback: subscribe() is already evoked');
+        this.onReceiveCallback = f;
+        return this;
+    };
+    RXSubscriber.prototype.onError = function (f) {
+        if (this.isComplete)
+            throw new Error('RXSubscriber is complete: It can not update onErrorCallback');
+        else if (this.isSubscribed)
+            throw new Error('RXSubscriber can not update onErrorCallback: subscribe() is already evoked');
+        this.onErrorCallback = f;
+        return this;
+    };
+    RXSubscriber.prototype.onComplete = function (f) {
+        if (this.isComplete)
+            throw new Error('RXSubscriber is complete: It can not update onCompleteCallback');
+        else if (this.isSubscribed)
+            throw new Error('RXSubscriber can not update onCompleteCallback: subscribe() is already evoked');
+        this.onCompleteCallback = f;
+        return this;
+    };
+    RXSubscriber.prototype.subscribe = function () {
+        var _this = this;
+        if (this.isSubscribed)
+            throw new Error('RXPipeline has already a subscriber');
+        this.isSubscribed = true;
+        this.pipeline.dispatcher.didSubscribe(this.pipeline);
+        return function () {
+            _this.unsubscribe();
+        };
+    };
+    RXSubscriber.prototype.unsubscribe = function () {
+        this.onReceiveCallback = undefined;
+        this.onErrorCallback = undefined;
+        this.onCompleteCallback = undefined;
+        this.pipeline.dispatcher.didUnsubscribe(this.pipeline);
+    };
+    return RXSubscriber;
+}());
+exports.RXSubscriber = RXSubscriber;

package/dist/cjs/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncDelay = exports.MD5 = exports.RXSubscriber = exports.RXPipeline = exports.RXReplaceError = exports.RXDebounce = exports.RXRemoveDuplicates = exports.RXSkipNullable = exports.RXSkipFirst = exports.RXSpread = exports.RXFilter = exports.RXParallel = exports.RXSequent = exports.RXForEach = exports.RXFlatMap = exports.RXMap = exports.RXOperator = exports.RenderQueueStatus = exports.ObservableGlobalState = exports.JSXSubscriber = exports.observer = exports.observeFrom = exports.observe = exports.RXQueue = exports.RXQueueOperator = exports.RXObservableValue = exports.RXObservableEntity = exports.RXWaitUntilComplete = exports.RXFrom = exports.RXCombine = exports.RXOperation = exports.RXBuffer = exports.RXSubject = exports.RXEmitter = exports.RXDelayedError = exports.RXDelayedComplete = exports.RXJustError = exports.RXJustComplete = exports.RXPublisher = exports.RX = void 0;
+var RX_js_1 = require("./RX.js");
+Object.defineProperty(exports, "RX", { enumerable: true, get: function () { return RX_js_1.RX; } });
+var RXPublisher_js_1 = require("./RXPublisher.js");
+Object.defineProperty(exports, "RXPublisher", { enumerable: true, get: function () { return RXPublisher_js_1.RXPublisher; } });
+Object.defineProperty(exports, "RXJustComplete", { enumerable: true, get: function () { return RXPublisher_js_1.RXJustComplete; } });
+Object.defineProperty(exports, "RXJustError", { enumerable: true, get: function () { return RXPublisher_js_1.RXJustError; } });
+Object.defineProperty(exports, "RXDelayedComplete", { enumerable: true, get: function () { return RXPublisher_js_1.RXDelayedComplete; } });
+Object.defineProperty(exports, "RXDelayedError", { enumerable: true, get: function () { return RXPublisher_js_1.RXDelayedError; } });
+Object.defineProperty(exports, "RXEmitter", { enumerable: true, get: function () { return RXPublisher_js_1.RXEmitter; } });
+Object.defineProperty(exports, "RXSubject", { enumerable: true, get: function () { return RXPublisher_js_1.RXSubject; } });
+Object.defineProperty(exports, "RXBuffer", { enumerable: true, get: function () { return RXPublisher_js_1.RXBuffer; } });
+Object.defineProperty(exports, "RXOperation", { enumerable: true, get: function () { return RXPublisher_js_1.RXOperation; } });
+Object.defineProperty(exports, "RXCombine", { enumerable: true, get: function () { return RXPublisher_js_1.RXCombine; } });
+Object.defineProperty(exports, "RXFrom", { enumerable: true, get: function () { return RXPublisher_js_1.RXFrom; } });
+Object.defineProperty(exports, "RXWaitUntilComplete", { enumerable: true, get: function () { return RXPublisher_js_1.RXWaitUntilComplete; } });
+Object.defineProperty(exports, "RXObservableEntity", { enumerable: true, get: function () { return RXPublisher_js_1.RXObservableEntity; } });
+Object.defineProperty(exports, "RXObservableValue", { enumerable: true, get: function () { return RXPublisher_js_1.RXObservableValue; } });
+Object.defineProperty(exports, "RXQueueOperator", { enumerable: true, get: function () { return RXPublisher_js_1.RXQueueOperator; } });
+Object.defineProperty(exports, "RXQueue", { enumerable: true, get: function () { return RXPublisher_js_1.RXQueue; } });
+var RXObserver_js_1 = require("./RXObserver.js");
+Object.defineProperty(exports, "observe", { enumerable: true, get: function () { return RXObserver_js_1.observe; } });
+Object.defineProperty(exports, "observeFrom", { enumerable: true, get: function () { return RXObserver_js_1.observeFrom; } });
+Object.defineProperty(exports, "observer", { enumerable: true, get: function () { return RXObserver_js_1.observer; } });
+Object.defineProperty(exports, "JSXSubscriber", { enumerable: true, get: function () { return RXObserver_js_1.JSXSubscriber; } });
+Object.defineProperty(exports, "ObservableGlobalState", { enumerable: true, get: function () { return RXObserver_js_1.ObservableGlobalState; } });
+Object.defineProperty(exports, "RenderQueueStatus", { enumerable: true, get: function () { return RXObserver_js_1.RenderQueueStatus; } });
+var RXOperator_js_1 = require("./RXOperator.js");
+Object.defineProperty(exports, "RXOperator", { enumerable: true, get: function () { return RXOperator_js_1.RXOperator; } });
+Object.defineProperty(exports, "RXMap", { enumerable: true, get: function () { return RXOperator_js_1.RXMap; } });
+Object.defineProperty(exports, "RXFlatMap", { enumerable: true, get: function () { return RXOperator_js_1.RXFlatMap; } });
+Object.defineProperty(exports, "RXForEach", { enumerable: true, get: function () { return RXOperator_js_1.RXForEach; } });
+Object.defineProperty(exports, "RXSequent", { enumerable: true, get: function () { return RXOperator_js_1.RXSequent; } });
+Object.defineProperty(exports, "RXParallel", { enumerable: true, get: function () { return RXOperator_js_1.RXParallel; } });
+Object.defineProperty(exports, "RXFilter", { enumerable: true, get: function () { return RXOperator_js_1.RXFilter; } });
+Object.defineProperty(exports, "RXSpread", { enumerable: true, get: function () { return RXOperator_js_1.RXSpread; } });
+Object.defineProperty(exports, "RXSkipFirst", { enumerable: true, get: function () { return RXOperator_js_1.RXSkipFirst; } });
+Object.defineProperty(exports, "RXSkipNullable", { enumerable: true, get: function () { return RXOperator_js_1.RXSkipNullable; } });
+Object.defineProperty(exports, "RXRemoveDuplicates", { enumerable: true, get: function () { return RXOperator_js_1.RXRemoveDuplicates; } });
+Object.defineProperty(exports, "RXDebounce", { enumerable: true, get: function () { return RXOperator_js_1.RXDebounce; } });
+Object.defineProperty(exports, "RXReplaceError", { enumerable: true, get: function () { return RXOperator_js_1.RXReplaceError; } });
+var RXPipeline_js_1 = require("./RXPipeline.js");
+Object.defineProperty(exports, "RXPipeline", { enumerable: true, get: function () { return RXPipeline_js_1.RXPipeline; } });
+var RXSubscriber_js_1 = require("./RXSubscriber.js");
+Object.defineProperty(exports, "RXSubscriber", { enumerable: true, get: function () { return RXSubscriber_js_1.RXSubscriber; } });
+var Utils_js_1 = require("./Utils.js");
+Object.defineProperty(exports, "MD5", { enumerable: true, get: function () { return Utils_js_1.MD5; } });
+Object.defineProperty(exports, "asyncDelay", { enumerable: true, get: function () { return Utils_js_1.asyncDelay; } });

package/dist/esm/RX.js

@@ -0,0 +1,38 @@
+import { RXCombine, RXDelayedComplete, RXDelayedError, RXFrom, RXJustComplete, RXJustError, RXQueue, RXWaitUntilComplete } from './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 RXCombine(list).asObservable;
+    };
+    RX.from = function (list) {
+        return new RXFrom(list).asObservable;
+    };
+    RX.queue = function () {
+        return new RXQueue();
+    };
+    RX.waitUntilComplete = function (list, result) {
+        return new RXWaitUntilComplete(list, result).asObservable;
+    };
+    RX.justComplete = function (value) {
+        return new RXJustComplete(value).asObservable;
+    };
+    RX.justError = function (error) {
+        return new RXJustError(error).asObservable;
+    };
+    RX.delayedComplete = function (ms, value) {
+        return new RXDelayedComplete(ms, value).asObservable;
+    };
+    RX.delayedError = function (ms, error) {
+        return new RXDelayedError(ms, error).asObservable;
+    };
+    return RX;
+}());
+export { RX };

package/dist/esm/RXObserver.js

@@ -0,0 +1,249 @@
+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));
+};
+import { useLayoutEffect, useRef, useState } from 'react';
+var __DEV__ = false;
+/*
+*
+*
+* GLOBAL OBSERVE METHODS
+*
+*
+* */
+export 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;
+}
+export 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!');
+        }
+    }
+}
+export function observer(component) {
+    return function (props) {
+        var subscriberRef = useRef(JSXSubscriber.empty);
+        var _a = useState(ObservableGlobalState.renderCycle), forceRender = _a[1];
+        if (subscriberRef.current === JSXSubscriber.empty) {
+            subscriberRef.current = new JSXSubscriber(function (renderCycle) {
+                forceRender(renderCycle);
+            });
+        }
+        if (__DEV__) {
+            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 {
+            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;
+}());
+export { JSXSubscriber };
+//--------------------------------------
+//  GlobalState
+//--------------------------------------
+var ObservableGlobalState = /** @class */ (function () {
+    function ObservableGlobalState() {
+    }
+    ObservableGlobalState.renderCycle = 0;
+    ObservableGlobalState.initializingJSXComponent = JSXSubscriber.empty;
+    ObservableGlobalState.debug = false;
+    return ObservableGlobalState;
+}());
+export { ObservableGlobalState };
+//--------------------------------------
+//  RenderQueue
+//--------------------------------------
+export var RenderQueueStatus;
+(function (RenderQueueStatus) {
+    RenderQueueStatus["IDLE"] = "IDLE";
+    RenderQueueStatus["PENDING"] = "PENDING";
+    RenderQueueStatus["RUNNING"] = "LOADING";
+})(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);
+};