flinker 1.0.0 → 1.0.6

package/dist/esm/RXPublisher.js

@@ -0,0 +1,730 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { RXPipeline } from './RXPipeline';
+//WeakRef is not supported in RN
+// export class RXPipelineGarbage {
+//   static self = new RXPipelineGarbage()
+//   private readonly list = Array<WeakRef<RXAnyPipeline>>()
+//   private total = 0
+//
+//   register(p: RXAnyPipeline) {
+//     this.list.push(new WeakRef(p))
+//     this.total++
+//     this.log()
+//   }
+//
+//   log() {
+//     const disposedCount = this.list.reduce((res, ref) => ref.deref() ? res + 1 : res, 0)
+//     Logger.i('GC: disposed pipelines:', disposedCount + '/' + this.total)
+//   }
+// }
+var generateSUID = (function () {
+    var value = 0;
+    return function () {
+        return value++;
+    };
+})();
+var RXPublisher = /** @class */ (function () {
+    function RXPublisher() {
+        this.suid = generateSUID();
+        this.type = 'observable';
+        this._isComplete = false;
+        this.pendingUnsubscribePipes = Array();
+        //--------------------------------------
+        //  Sending methods
+        //--------------------------------------
+        this.isSending = false;
+        this.pipelines = Array();
+    }
+    Object.defineProperty(RXPublisher.prototype, "volume", {
+        get: function () { return this.pipelines.length; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXPublisher.prototype, "asObservable", {
+        get: function () { return this; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXPublisher.prototype, "isComplete", {
+        get: function () { return this._isComplete; },
+        enumerable: false,
+        configurable: true
+    });
+    RXPublisher.prototype.pipe = function () {
+        var pipe = new RXPipeline(this);
+        this.pipelines.push(pipe);
+        //RXPipelineGarbage.self.register(pipe)
+        return pipe.asOperator;
+    };
+    RXPublisher.prototype.didSubscribe = function (p) {
+        this.isComplete && p.sendComplete(false);
+    };
+    RXPublisher.prototype.didUnsubscribe = function (p) {
+        if (this.isSending) {
+            this.pendingUnsubscribePipes.push(p);
+            return;
+        }
+        var index = this.pipelines.indexOf(p);
+        index !== -1 && this.pipelines.splice(index, 1);
+    };
+    RXPublisher.prototype.send = function (value) {
+        this.isSending = true;
+        this.pipelines.forEach(function (i) { i.send(value, true); });
+        this.isSending = false;
+        this.runPendingOperations();
+    };
+    RXPublisher.prototype.sendError = function (e) {
+        this.isSending = true;
+        this.pipelines.forEach(function (i) { i.sendError(e, true); });
+        this.isSending = false;
+        this.runPendingOperations();
+    };
+    RXPublisher.prototype.sendComplete = function () {
+        this.isSending = true;
+        this._isComplete = true;
+        this.pipelines.forEach(function (i) { i.sendComplete(true); });
+        this.pipelines.length = 0;
+        this.isSending = false;
+        this.runPendingOperations();
+    };
+    RXPublisher.prototype.runPendingOperations = function () {
+        var _this = this;
+        if (this.isSending)
+            return;
+        if (this.pendingUnsubscribePipes.length > 0) {
+            this.pendingUnsubscribePipes.forEach(function (p) { _this.didUnsubscribe(p); });
+            this.pendingUnsubscribePipes.length = 0;
+        }
+    };
+    return RXPublisher;
+}());
+export { RXPublisher };
+//--------------------------------------
+//  RXJustComplete
+//--------------------------------------
+var RXJustComplete = /** @class */ (function (_super) {
+    __extends(RXJustComplete, _super);
+    function RXJustComplete(value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        value !== undefined && _this.send(value);
+        _this.sendComplete();
+        return _this;
+    }
+    RXJustComplete.prototype.didSubscribe = function (p) {
+        this.isComplete && this.value !== undefined && p.send(this.value, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXJustComplete;
+}(RXPublisher));
+export { RXJustComplete };
+//--------------------------------------
+//  RXJustError
+//--------------------------------------
+var RXJustError = /** @class */ (function (_super) {
+    __extends(RXJustError, _super);
+    function RXJustError(error) {
+        var _this = _super.call(this) || this;
+        _this.error = error;
+        _this.sendError(error);
+        _this.sendComplete();
+        return _this;
+    }
+    RXJustError.prototype.didSubscribe = function (p) {
+        this.isComplete && p.sendError(this.error, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXJustError;
+}(RXPublisher));
+export { RXJustError };
+//--------------------------------------
+//  RXDelayedComplete
+//--------------------------------------
+var RXDelayedComplete = /** @class */ (function (_super) {
+    __extends(RXDelayedComplete, _super);
+    function RXDelayedComplete(ms, value) {
+        var _this = _super.call(this) || this;
+        _this.value = value;
+        setTimeout(function () {
+            value !== undefined && _this.send(value);
+            _this.sendComplete();
+        }, ms);
+        return _this;
+    }
+    RXDelayedComplete.prototype.didSubscribe = function (p) {
+        this.isComplete && this.value !== undefined && p.send(this.value, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXDelayedComplete;
+}(RXPublisher));
+export { RXDelayedComplete };
+//--------------------------------------
+//  RXDelayedError
+//--------------------------------------
+var RXDelayedError = /** @class */ (function (_super) {
+    __extends(RXDelayedError, _super);
+    function RXDelayedError(ms, error) {
+        var _this = _super.call(this) || this;
+        _this.error = error;
+        setTimeout(function () {
+            _this.sendError(error);
+            _this.sendComplete();
+        }, ms);
+        return _this;
+    }
+    RXDelayedError.prototype.didSubscribe = function (p) {
+        this.isComplete && p.sendError(this.error, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXDelayedError;
+}(RXPublisher));
+export { RXDelayedError };
+//--------------------------------------
+//  RXEmitter
+//--------------------------------------
+var RXEmitter = /** @class */ (function (_super) {
+    __extends(RXEmitter, _super);
+    function RXEmitter() {
+        var _this = this;
+        console.log('new RXEmitter');
+        _this = _super.call(this) || this;
+        _this._hasValue = false;
+        _this.hasError = false;
+        _this._err = undefined;
+        return _this;
+    }
+    Object.defineProperty(RXEmitter.prototype, "value", {
+        get: function () { return this._value; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXEmitter.prototype, "err", {
+        get: function () { return this._err; },
+        enumerable: false,
+        configurable: true
+    });
+    RXEmitter.prototype.send = function (value) {
+        if (this.isComplete)
+            return;
+        this._value = value;
+        this._hasValue = true;
+        _super.prototype.send.call(this, value);
+    };
+    RXEmitter.prototype.sendError = function (e) {
+        if (this.isComplete)
+            return;
+        this._err = e;
+        this.hasError = true;
+        _super.prototype.sendError.call(this, e);
+    };
+    RXEmitter.prototype.sendComplete = function () {
+        if (this.isComplete)
+            return;
+        _super.prototype.sendComplete.call(this);
+    };
+    RXEmitter.prototype.didSubscribe = function (p) {
+        this.hasError && p.sendError(this.err, false);
+        !this.hasError && this._hasValue && p.send(this.value, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXEmitter;
+}(RXPublisher));
+export { RXEmitter };
+//--------------------------------------
+//  RXSubject
+//--------------------------------------
+var RXSubject = /** @class */ (function (_super) {
+    __extends(RXSubject, _super);
+    function RXSubject(value) {
+        var _this = _super.call(this) || this;
+        _this._hasError = false;
+        _this._err = undefined;
+        _this._value = value;
+        return _this;
+    }
+    Object.defineProperty(RXSubject.prototype, "value", {
+        get: function () { return this._value; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXSubject.prototype, "err", {
+        get: function () {
+            return this._err;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RXSubject.prototype.send = function (value) {
+        if (this.isComplete)
+            return;
+        this._value = value;
+        _super.prototype.send.call(this, value);
+    };
+    RXSubject.prototype.resend = function () {
+        _super.prototype.send.call(this, this.value);
+    };
+    RXSubject.prototype.sendError = function (e) {
+        if (this.isComplete)
+            return;
+        this._err = e;
+        this._hasError = true;
+        _super.prototype.sendError.call(this, e);
+    };
+    RXSubject.prototype.sendComplete = function () {
+        if (this.isComplete)
+            return;
+        this._isComplete = true;
+        _super.prototype.sendComplete.call(this);
+    };
+    RXSubject.prototype.didSubscribe = function (p) {
+        this._hasError && p.sendError(this.err, false);
+        !this._hasError && p.send(this.value, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXSubject;
+}(RXPublisher));
+export { RXSubject };
+//--------------------------------------
+//  RXBuffer
+//--------------------------------------
+var RXBuffer = /** @class */ (function (_super) {
+    __extends(RXBuffer, _super);
+    function RXBuffer() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.values = Array();
+        _this.errors = Array();
+        _this.isError = Array();
+        return _this;
+    }
+    RXBuffer.prototype.send = function (value) {
+        if (this.isComplete)
+            return;
+        this.values.push(value);
+        this.isError.push(false);
+        _super.prototype.send.call(this, value);
+    };
+    RXBuffer.prototype.sendError = function (e) {
+        if (this.isComplete)
+            return;
+        this.errors.push(e);
+        this.isError.push(true);
+        _super.prototype.sendError.call(this, e);
+    };
+    RXBuffer.prototype.sendComplete = function () {
+        if (this.isComplete)
+            return;
+        this._isComplete = true;
+        _super.prototype.sendComplete.call(this);
+    };
+    RXBuffer.prototype.didSubscribe = function (p) {
+        for (var i = 0, v = 0, e = 0; i < this.isError.length; i++) {
+            if (this.isError[i]) {
+                e < this.errors.length && p.sendError(this.errors[e], false);
+                e++;
+            }
+            else {
+                v < this.values.length && p.send(this.values[v], false);
+                v++;
+            }
+        }
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXBuffer;
+}(RXPublisher));
+export { RXBuffer };
+//--------------------------------------
+//  RXOperation
+//--------------------------------------
+var RXOperation = /** @class */ (function (_super) {
+    __extends(RXOperation, _super);
+    function RXOperation() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._value = undefined;
+        _this._hasError = false;
+        _this._err = undefined;
+        return _this;
+    }
+    Object.defineProperty(RXOperation.prototype, "value", {
+        get: function () { return this._value; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXOperation.prototype, "err", {
+        get: function () { return this._err; },
+        enumerable: false,
+        configurable: true
+    });
+    RXOperation.prototype.success = function (value) {
+        if (this.isComplete)
+            return;
+        this._value = value;
+        _super.prototype.send.call(this, value);
+        _super.prototype.sendComplete.call(this);
+    };
+    RXOperation.prototype.fail = function (e) {
+        if (this.isComplete)
+            return;
+        this._err = e;
+        this._hasError = true;
+        _super.prototype.sendError.call(this, e);
+        _super.prototype.sendComplete.call(this);
+    };
+    RXOperation.prototype.didSubscribe = function (p) {
+        if (!this.isComplete)
+            return;
+        if (this._hasError) {
+            p.sendError(this.err, false);
+            p.sendComplete(false);
+        }
+        else {
+            p.send(this.value, false);
+            p.sendComplete(false);
+        }
+    };
+    return RXOperation;
+}(RXPublisher));
+export { RXOperation };
+//--------------------------------------
+//  RXCombine
+//--------------------------------------
+var RXCombine = /** @class */ (function (_super) {
+    __extends(RXCombine, _super);
+    function RXCombine(list) {
+        var _this = this;
+        console.log('new RXCombine');
+        _this = _super.call(this) || this;
+        _this._values = [];
+        _this._hasError = false;
+        _this._err = undefined;
+        var count = list.length;
+        _this._values = new Array(list.length).fill(undefined);
+        list.forEach(function (rx, ind) {
+            var op = rx instanceof RXPublisher ? rx.asObservable.pipe() : rx;
+            op.onReceive(function (v) {
+                _this.values[ind] = v;
+                _super.prototype.send.call(_this, _this.values);
+            })
+                .onError(function (e) {
+                _this._err = e;
+                _this._hasError = true;
+                _super.prototype.sendError.call(_this, e);
+            })
+                .onComplete(function () {
+                count--;
+                if (count === 0) {
+                    _this._isComplete = true;
+                    _super.prototype.sendComplete.call(_this);
+                }
+            })
+                .subscribe();
+        });
+        if (count === 0) {
+            _super.prototype.sendComplete.call(_this);
+        }
+        return _this;
+    }
+    Object.defineProperty(RXCombine.prototype, "values", {
+        get: function () { return this._values; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXCombine.prototype, "err", {
+        get: function () { return this._err; },
+        enumerable: false,
+        configurable: true
+    });
+    RXCombine.prototype.didSubscribe = function (p) {
+        !this._hasError && p.send(this.values, false);
+        this._hasError && p.sendError(this.err, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXCombine;
+}(RXPublisher));
+export { RXCombine };
+//--------------------------------------
+//  RXFrom
+//--------------------------------------
+var RXFrom = /** @class */ (function (_super) {
+    __extends(RXFrom, _super);
+    function RXFrom(list) {
+        var _this = this;
+        console.log('new RXFrom');
+        _this = _super.call(this) || this;
+        _this.values = list;
+        _this.sendComplete();
+        return _this;
+    }
+    RXFrom.prototype.didSubscribe = function (p) {
+        this.values.forEach(function (v) { p.send(v, false); });
+        p.sendComplete(false);
+    };
+    return RXFrom;
+}(RXPublisher));
+export { RXFrom };
+//--------------------------------------
+//  RXWaitUntilComplete
+//--------------------------------------
+/*
+  * wait until all publishers are complete and then send a value of the last publisher if it's specified
+  * */
+var RXWaitUntilComplete = /** @class */ (function (_super) {
+    __extends(RXWaitUntilComplete, _super);
+    function RXWaitUntilComplete(list, resultPublisher) {
+        var _this = this;
+        console.log('new RXSequence');
+        _this = _super.call(this) || this;
+        _this._value = undefined;
+        _this._hasError = false;
+        _this._err = undefined;
+        _this._resultPublisher = resultPublisher;
+        var count = Array.isArray(list) ? list.length : 1;
+        if (Array.isArray(list)) {
+            list.forEach(function (ob) {
+                return ob.pipe()
+                    .onError(function (e) {
+                    _this._err = e;
+                    _this._hasError = true;
+                    _super.prototype.sendError.call(_this, e);
+                })
+                    .onComplete(function () {
+                    count--;
+                    if (count === 0)
+                        _this.subscribeToResultPublisher();
+                })
+                    .subscribe();
+            });
+            if (count === 0)
+                _this.subscribeToResultPublisher();
+        }
+        else {
+            list.pipe()
+                .onError(function (e) {
+                _this._err = e;
+                _this._hasError = true;
+                _super.prototype.sendError.call(_this, e);
+            })
+                .onComplete(function () {
+                _this.subscribeToResultPublisher();
+            })
+                .subscribe();
+        }
+        return _this;
+    }
+    Object.defineProperty(RXWaitUntilComplete.prototype, "value", {
+        get: function () { return this._value; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXWaitUntilComplete.prototype, "err", {
+        get: function () { return this._err; },
+        enumerable: false,
+        configurable: true
+    });
+    RXWaitUntilComplete.prototype.subscribeToResultPublisher = function () {
+        var _this = this;
+        if (this._resultPublisher) {
+            this._resultPublisher.pipe()
+                .onReceive(function (v) {
+                _this._value = v;
+                _super.prototype.send.call(_this, v);
+            })
+                .onError(function (e) {
+                _this._err = e;
+                _this._hasError = true;
+                _super.prototype.sendError.call(_this, e);
+            })
+                .onComplete(function () {
+                _this._isComplete = true;
+                _super.prototype.sendComplete.call(_this);
+            })
+                .subscribe();
+        }
+        else {
+            this._isComplete = true;
+            _super.prototype.sendComplete.call(this);
+        }
+    };
+    RXWaitUntilComplete.prototype.didSubscribe = function (p) {
+        var _a;
+        !this._hasError && this.isComplete && ((_a = this._resultPublisher) === null || _a === void 0 ? void 0 : _a.isComplete) && p.send(this.value, false);
+        this._hasError && p.sendError(this.err, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXWaitUntilComplete;
+}(RXPublisher));
+export { RXWaitUntilComplete };
+/*
+*
+* UI
+*
+* */
+//--------------------------------------
+//  RXObservableEntity
+//--------------------------------------
+var RXObservableEntity = /** @class */ (function (_super) {
+    __extends(RXObservableEntity, _super);
+    function RXObservableEntity() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RXObservableEntity.prototype.mutated = function () {
+        this.send(this);
+    };
+    RXObservableEntity.prototype.send = function (value) {
+        _super.prototype.send.call(this, value);
+    };
+    RXObservableEntity.prototype.dispose = function () {
+        this.sendComplete();
+    };
+    RXObservableEntity.prototype.didSubscribe = function (p) {
+        p.send(this, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXObservableEntity;
+}(RXPublisher));
+export { RXObservableEntity };
+//--------------------------------------
+//  RXMutableValue
+//--------------------------------------
+var RXObservableValue = /** @class */ (function (_super) {
+    __extends(RXObservableValue, _super);
+    function RXObservableValue(value) {
+        var _this = _super.call(this) || this;
+        _this._value = value;
+        return _this;
+    }
+    Object.defineProperty(RXObservableValue.prototype, "value", {
+        get: function () { return this._value; },
+        set: function (value) {
+            if (value !== this._value) {
+                this._value = value;
+                _super.prototype.send.call(this, value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RXObservableValue.prototype.didSubscribe = function (p) {
+        p.send(this.value, false);
+        this.isComplete && p.sendComplete(false);
+    };
+    return RXObservableValue;
+}(RXPublisher));
+export { RXObservableValue };
+var RXQueueOperator = /** @class */ (function () {
+    function RXQueueOperator(op) {
+        this.inProgress = true;
+        this.value = undefined;
+        this.op = op;
+    }
+    //--------------------------------------
+    //  RXSender Protocol
+    //--------------------------------------
+    RXQueueOperator.prototype.send = function (value) {
+        var _a;
+        if (!this.op.isComplete) {
+            (_a = this.child) === null || _a === void 0 ? void 0 : _a.send(value);
+        }
+    };
+    //--------------------------------------
+    //  OPERATORS
+    //--------------------------------------
+    RXQueueOperator.prototype.next = function (f) {
+        var operator = this.addChild(new RXQueueNext(this.op, f));
+        if (!this.inProgress) {
+            operator.send(this.value);
+        }
+        return operator;
+    };
+    RXQueueOperator.prototype.addChild = function (op) {
+        this.child = op;
+        return op;
+    };
+    RXQueueOperator.prototype.complete = function () {
+        var _this = this;
+        if (!this.op.isComplete) {
+            this.next(function (res) {
+                _this.op.success(res);
+                return _this.op;
+            });
+        }
+        return this.op.asObservable;
+    };
+    return RXQueueOperator;
+}());
+export { RXQueueOperator };
+var RXQueueNext = /** @class */ (function (_super) {
+    __extends(RXQueueNext, _super);
+    function RXQueueNext(op, mapper) {
+        var _this = _super.call(this, op) || this;
+        _this.mapper = mapper;
+        return _this;
+    }
+    RXQueueNext.prototype.send = function (value) {
+        var _this = this;
+        if (this.op.isComplete)
+            return;
+        var rx = this.mapper(value);
+        rx.pipe()
+            .onReceive(function (v) {
+            _this.value = v;
+        })
+            .onError(function (e) {
+            _this.op.fail(e);
+        })
+            .onComplete(function () {
+            _this.inProgress = false;
+            _super.prototype.send.call(_this, _this.value);
+        })
+            .subscribe();
+    };
+    return RXQueueNext;
+}(RXQueueOperator));
+var RXQueue = /** @class */ (function (_super) {
+    __extends(RXQueue, _super);
+    function RXQueue() {
+        var _this = _super.call(this, new RXOperation()) || this;
+        _this.inProgress = false;
+        return _this;
+    }
+    Object.defineProperty(RXQueue.prototype, "asObservable", {
+        //--------------------------------------
+        //  asObservable
+        //--------------------------------------
+        get: function () { return this.op.asObservable; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RXQueue.prototype, "isComplete", {
+        //--------------------------------------
+        //  isComplete
+        //--------------------------------------
+        get: function () { return this.op.isComplete; },
+        enumerable: false,
+        configurable: true
+    });
+    RXQueue.prototype.next = function (f) {
+        return _super.prototype.next.call(this, f);
+    };
+    RXQueue.prototype.success = function (v) {
+        this.op.success(v);
+    };
+    RXQueue.prototype.fail = function (e) {
+        this.op.fail(e);
+    };
+    return RXQueue;
+}(RXQueueOperator));
+export { RXQueue };