xstream/extra/flattenConcurrently.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var index_1 = require("../index");
var FCIL = /** @class */ (function () {
    function FCIL(out, op) {
        this.out = out;
        this.op = op;
    }
    FCIL.prototype._n = function (t) {
        this.out._n(t);
    };
    FCIL.prototype._e = function (err) {
        this.out._e(err);
    };
    FCIL.prototype._c = function () {
        this.op.less();
    };
    return FCIL;
}());
var FlattenConcOperator = /** @class */ (function () {
    function FlattenConcOperator(ins) {
        this.ins = ins;
        this.type = 'flattenConcurrently';
        this.active = 1; // number of outers and inners that have not yet ended
        this.out = null;
    }
    FlattenConcOperator.prototype._start = function (out) {
        this.out = out;
        this.ins._add(this);
    };
    FlattenConcOperator.prototype._stop = function () {
        this.ins._remove(this);
        this.active = 1;
        this.out = null;
    };
    FlattenConcOperator.prototype.less = function () {
        if (--this.active === 0) {
            var u = this.out;
            if (!u)
                return;
            u._c();
        }
    };
    FlattenConcOperator.prototype._n = function (s) {
        var u = this.out;
        if (!u)
            return;
        this.active++;
        s._add(new FCIL(u, this));
    };
    FlattenConcOperator.prototype._e = function (err) {
        var u = this.out;
        if (!u)
            return;
        u._e(err);
    };
    FlattenConcOperator.prototype._c = function () {
        this.less();
    };
    return FlattenConcOperator;
}());
exports.FlattenConcOperator = FlattenConcOperator;
/**
 * Flattens a "stream of streams", handling multiple concurrent nested streams
 * simultaneously.
 *
 * If the input stream is a stream that emits streams, then this operator will
 * return an output stream which is a flat stream: emits regular events. The
 * flattening happens concurrently. It works like this: when the input stream
 * emits a nested stream, *flattenConcurrently* will start imitating that
 * nested one. When the next nested stream is emitted on the input stream,
 * *flattenConcurrently* will also imitate that new one, but will continue to
 * imitate the previous nested streams as well.
 *
 * Marble diagram:
 *
 * ```text
 * --+--------+---------------
 *   \        \
 *    \       ----1----2---3--
 *    --a--b----c----d--------
 *     flattenConcurrently
 * -----a--b----c-1--d-2---3--
 * ```
 *
 * @return {Stream}
 */
function flattenConcurrently(ins) {
    return new index_1.Stream(new FlattenConcOperator(ins));
}
exports.default = flattenConcurrently;
//# sourceMappingURL=data:application/json;base64,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