semver-range-intersect/dist/multi-range.js

Get the intersection of multiple semver ranges.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const single_range_1 = require("./single-range");
const utils_1 = require("./utils");
function normalizeSingleRangeList(singleRangeList) {
    return singleRangeList.reduce((singleRangeList, singleRange) => {
        if (!singleRange) {
            return [...singleRangeList, singleRange];
        }
        let insertFirst = false;
        const removeIndexList = [];
        const appendSingleRange = singleRangeList.reduce((appendSingleRange, insertedSingleRange, index) => {
            if (insertedSingleRange && appendSingleRange) {
                const mergedSingleRange = insertedSingleRange.merge(appendSingleRange);
                if (mergedSingleRange) {
                    if (String(mergedSingleRange) ===
                        String(insertedSingleRange)) {
                        return;
                    }
                    else {
                        removeIndexList.push(index);
                        if (insertedSingleRange instanceof single_range_1.SingleRange &&
                            appendSingleRange instanceof single_range_1.SingleRange) {
                            insertFirst = true;
                        }
                        return mergedSingleRange;
                    }
                }
            }
            return appendSingleRange;
        }, singleRange);
        const removedSingleRangeList = singleRangeList.filter((_, index) => !removeIndexList.includes(index));
        if (appendSingleRange) {
            if (insertFirst) {
                return [appendSingleRange, ...removedSingleRangeList];
            }
            else {
                return [...removedSingleRangeList, appendSingleRange];
            }
        }
        return removedSingleRangeList;
    }, []);
}
exports.normalizeSingleRangeList = normalizeSingleRangeList;
class MultiRange {
    get valid() {
        return this.set.length >= 1;
    }
    constructor(rangeList) {
        if (rangeList) {
            const singleRangeList = normalizeSingleRangeList(rangeList.map(singleRangeOrComparatorList => {
                if (single_range_1.isSingleRange(singleRangeOrComparatorList) ||
                    !singleRangeOrComparatorList) {
                    return singleRangeOrComparatorList;
                }
                else {
                    return single_range_1.createSingleRange(singleRangeOrComparatorList);
                }
            }));
            this.set = singleRangeList.filter(utils_1.isNotNull);
        }
        else {
            this.set = [];
        }
    }
    toString() {
        if (!this.valid) {
            throw new Error('Invalid range');
        }
        return utils_1.uniqueArray(this.set.map(String)).join(' || ');
    }
    intersect(multiRange) {
        if (this.valid && multiRange.valid) {
            const singleRangeList = this.set
                .map(singleRangeA => multiRange.set.map(singleRangeB => singleRangeA.intersect(singleRangeB)))
                .reduce((a, b) => [...a, ...b])
                .filter(utils_1.isNotNull);
            return new MultiRange(singleRangeList);
        }
        else if (this.valid) {
            return this;
        }
        else if (multiRange.valid) {
            return multiRange;
        }
        else {
            return new MultiRange(null);
        }
    }
}
exports.MultiRange = MultiRange;
//# sourceMappingURL=multi-range.js.map