iterable-joiner/js/Sync.js

combine multiple Iterable or AsyncIterable objects into one

"use strict";
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Sync = void 0;
var Sync;
(function (Sync) {
    var _Abstract_iterables, _Abstract_handlers;
    class Abstract {
        constructor(...iterables) {
            _Abstract_iterables.set(this, void 0);
            _Abstract_handlers.set(this, {
                add: [],
                remove: [],
            });
            __classPrivateFieldSet(this, _Abstract_iterables, iterables, "f");
        }
        get iterables() {
            return __classPrivateFieldGet(this, _Abstract_iterables, "f");
        }
        *[(_Abstract_iterables = new WeakMap(), _Abstract_handlers = new WeakMap(), Symbol.iterator)]() {
            const self = this;
            const iterables = [];
            const nextFunctions = [];
            __classPrivateFieldGet(this, _Abstract_iterables, "f").map(startIterating);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").add.push(startIterating);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").remove.push(stopIterating);
            yield* this._merge(nextFunctions);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").add.splice(__classPrivateFieldGet(this, _Abstract_handlers, "f").add.indexOf(startIterating), 1);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").remove.splice(__classPrivateFieldGet(this, _Abstract_handlers, "f").remove.indexOf(startIterating), 1);
            function startIterating(iterable) {
                const idx = __classPrivateFieldGet(self, _Abstract_iterables, "f").indexOf(iterable);
                if (idx === -1) {
                    return false;
                }
                const iterator = iterable[Symbol.iterator]();
                function next() {
                    const result = iterator.next();
                    if (result.done) {
                        stopIterating(iterable);
                    }
                    return result;
                }
                ;
                iterables.splice(idx, 0, iterable);
                nextFunctions.splice(idx, 0, next);
                return true;
            }
            function stopIterating(iterable) {
                const idx = iterables.indexOf(iterable);
                if (idx === -1) {
                    return false;
                }
                iterables.splice(idx, 1);
                nextFunctions.splice(idx, 1);
                return true;
            }
        }
        addIterable(it, idx = __classPrivateFieldGet(this, _Abstract_iterables, "f").length) {
            if (isIterable(it) === false || __classPrivateFieldGet(this, _Abstract_iterables, "f").includes(it) === true) {
                return false;
            }
            if (typeof idx !== "number") {
                return false;
            }
            else {
                if (idx < 0) {
                    idx = 0;
                }
                else if (idx > __classPrivateFieldGet(this, _Abstract_iterables, "f").length) {
                    idx = __classPrivateFieldGet(this, _Abstract_iterables, "f").length;
                }
            }
            __classPrivateFieldGet(this, _Abstract_iterables, "f").splice(idx, 0, it);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").add.forEach(f => f(it));
            return true;
        }
        removeIterable(it) {
            if (isIterable(it) === false || __classPrivateFieldGet(this, _Abstract_iterables, "f").includes(it) === false) {
                return false;
            }
            __classPrivateFieldGet(this, _Abstract_iterables, "f").splice(__classPrivateFieldGet(this, _Abstract_iterables, "f").indexOf(it), 1);
            __classPrivateFieldGet(this, _Abstract_handlers, "f").remove.forEach(f => f(it));
            return true;
        }
    }
    Sync.Abstract = Abstract;
    class Equitable extends Abstract {
        constructor() {
            super(...arguments);
            this.priority = false;
        }
        _merge(nextFunctions) {
            const priority = this.priority;
            return {
                *[Symbol.iterator]() {
                    while (nextFunctions.length) {
                        for (let i = 0; i < nextFunctions.length; i++) {
                            const { done, value } = nextFunctions[i]();
                            if (done === true) {
                                i--;
                            }
                            else {
                                yield value;
                                if (priority) {
                                    break;
                                }
                            }
                        }
                    }
                }
            };
        }
        static join(...iterables) {
            return new Equitable(...iterables);
        }
    }
    Sync.Equitable = Equitable;
    class Priority extends Equitable {
        constructor() {
            super(...arguments);
            this.priority = true;
        }
        static join(...iterables) {
            return new Priority(...iterables);
        }
    }
    Sync.Priority = Priority;
})(Sync = exports.Sync || (exports.Sync = {}));
function isIterable(value) {
    return value.hasOwnProperty(Symbol.iterator);
}