| const Range = require('../classes/range.js') |
| const { ANY } = require('../classes/comparator.js') |
| const satisfies = require('../functions/satisfies.js') |
| const compare = require('../functions/compare.js') |
| |
| // Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff: |
| // - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...` |
| // |
| // Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff: |
| // - If c is only the ANY comparator |
| // - If C is only the ANY comparator, return true |
| // - Else return false |
| // - Let EQ be the set of = comparators in c |
| // - If EQ is more than one, return true (null set) |
| // - Let GT be the highest > or >= comparator in c |
| // - Let LT be the lowest < or <= comparator in c |
| // - If GT and LT, and GT.semver > LT.semver, return true (null set) |
| // - If EQ |
| // - If GT, and EQ does not satisfy GT, return true (null set) |
| // - If LT, and EQ does not satisfy LT, return true (null set) |
| // - If EQ satisfies every C, return true |
| // - Else return false |
| // - If GT |
| // - If GT is lower than any > or >= comp in C, return false |
| // - If GT is >=, and GT.semver does not satisfy every C, return false |
| // - If LT |
| // - If LT.semver is greater than that of any > comp in C, return false |
| // - If LT is <=, and LT.semver does not satisfy every C, return false |
| // - If any C is a = range, and GT or LT are set, return false |
| // - Else return true |
| |
| const subset = (sub, dom, options) => { |
| sub = new Range(sub, options) |
| dom = new Range(dom, options) |
| let sawNonNull = false |
| |
| OUTER: for (const simpleSub of sub.set) { |
| for (const simpleDom of dom.set) { |
| const isSub = simpleSubset(simpleSub, simpleDom, options) |
| sawNonNull = sawNonNull || isSub !== null |
| if (isSub) |
| continue OUTER |
| } |
| // the null set is a subset of everything, but null simple ranges in |
| // a complex range should be ignored. so if we saw a non-null range, |
| // then we know this isn't a subset, but if EVERY simple range was null, |
| // then it is a subset. |
| if (sawNonNull) |
| return false |
| } |
| return true |
| } |
| |
| const simpleSubset = (sub, dom, options) => { |
| if (sub.length === 1 && sub[0].semver === ANY) |
| return dom.length === 1 && dom[0].semver === ANY |
| |
| const eqSet = new Set() |
| let gt, lt |
| for (const c of sub) { |
| if (c.operator === '>' || c.operator === '>=') |
| gt = higherGT(gt, c, options) |
| else if (c.operator === '<' || c.operator === '<=') |
| lt = lowerLT(lt, c, options) |
| else |
| eqSet.add(c.semver) |
| } |
| |
| if (eqSet.size > 1) |
| return null |
| |
| let gtltComp |
| if (gt && lt) { |
| gtltComp = compare(gt.semver, lt.semver, options) |
| if (gtltComp > 0) |
| return null |
| else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) |
| return null |
| } |
| |
| // will iterate one or zero times |
| for (const eq of eqSet) { |
| if (gt && !satisfies(eq, String(gt), options)) |
| return null |
| |
| if (lt && !satisfies(eq, String(lt), options)) |
| return null |
| |
| for (const c of dom) { |
| if (!satisfies(eq, String(c), options)) |
| return false |
| } |
| return true |
| } |
| |
| let higher, lower |
| let hasDomLT, hasDomGT |
| for (const c of dom) { |
| hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=' |
| hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=' |
| if (gt) { |
| if (c.operator === '>' || c.operator === '>=') { |
| higher = higherGT(gt, c, options) |
| if (higher === c) |
| return false |
| } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) |
| return false |
| } |
| if (lt) { |
| if (c.operator === '<' || c.operator === '<=') { |
| lower = lowerLT(lt, c, options) |
| if (lower === c) |
| return false |
| } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) |
| return false |
| } |
| if (!c.operator && (lt || gt) && gtltComp !== 0) |
| return false |
| } |
| |
| // if there was a < or >, and nothing in the dom, then must be false |
| // UNLESS it was limited by another range in the other direction. |
| // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0 |
| if (gt && hasDomLT && !lt && gtltComp !== 0) |
| return false |
| |
| if (lt && hasDomGT && !gt && gtltComp !== 0) |
| return false |
| |
| return true |
| } |
| |
| // >=1.2.3 is lower than >1.2.3 |
| const higherGT = (a, b, options) => { |
| if (!a) |
| return b |
| const comp = compare(a.semver, b.semver, options) |
| return comp > 0 ? a |
| : comp < 0 ? b |
| : b.operator === '>' && a.operator === '>=' ? b |
| : a |
| } |
| |
| // <=1.2.3 is higher than <1.2.3 |
| const lowerLT = (a, b, options) => { |
| if (!a) |
| return b |
| const comp = compare(a.semver, b.semver, options) |
| return comp < 0 ? a |
| : comp > 0 ? b |
| : b.operator === '<' && a.operator === '<=' ? b |
| : a |
| } |
| |
| module.exports = subset |