|
const Range = require('../classes/range.js') |
|
const Comparator = require('../classes/comparator.js') |
|
const { ANY } = Comparator |
|
const satisfies = require('../functions/satisfies.js') |
|
const compare = require('../functions/compare.js') |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const subset = (sub, dom, options = {}) => { |
|
if (sub === dom) { |
|
return true |
|
} |
|
|
|
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 |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
if (sawNonNull) { |
|
return false |
|
} |
|
} |
|
return true |
|
} |
|
|
|
const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')] |
|
const minimumVersion = [new Comparator('>=0.0.0')] |
|
|
|
const simpleSubset = (sub, dom, options) => { |
|
if (sub === dom) { |
|
return true |
|
} |
|
|
|
if (sub.length === 1 && sub[0].semver === ANY) { |
|
if (dom.length === 1 && dom[0].semver === ANY) { |
|
return true |
|
} else if (options.includePrerelease) { |
|
sub = minimumVersionWithPreRelease |
|
} else { |
|
sub = minimumVersion |
|
} |
|
} |
|
|
|
if (dom.length === 1 && dom[0].semver === ANY) { |
|
if (options.includePrerelease) { |
|
return true |
|
} else { |
|
dom = minimumVersion |
|
} |
|
} |
|
|
|
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 |
|
} |
|
} |
|
|
|
|
|
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 |
|
|
|
|
|
let needDomLTPre = lt && |
|
!options.includePrerelease && |
|
lt.semver.prerelease.length ? lt.semver : false |
|
let needDomGTPre = gt && |
|
!options.includePrerelease && |
|
gt.semver.prerelease.length ? gt.semver : false |
|
|
|
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && |
|
lt.operator === '<' && needDomLTPre.prerelease[0] === 0) { |
|
needDomLTPre = false |
|
} |
|
|
|
for (const c of dom) { |
|
hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=' |
|
hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=' |
|
if (gt) { |
|
if (needDomGTPre) { |
|
if (c.semver.prerelease && c.semver.prerelease.length && |
|
c.semver.major === needDomGTPre.major && |
|
c.semver.minor === needDomGTPre.minor && |
|
c.semver.patch === needDomGTPre.patch) { |
|
needDomGTPre = false |
|
} |
|
} |
|
if (c.operator === '>' || c.operator === '>=') { |
|
higher = higherGT(gt, c, options) |
|
if (higher === c && higher !== gt) { |
|
return false |
|
} |
|
} else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) { |
|
return false |
|
} |
|
} |
|
if (lt) { |
|
if (needDomLTPre) { |
|
if (c.semver.prerelease && c.semver.prerelease.length && |
|
c.semver.major === needDomLTPre.major && |
|
c.semver.minor === needDomLTPre.minor && |
|
c.semver.patch === needDomLTPre.patch) { |
|
needDomLTPre = false |
|
} |
|
} |
|
if (c.operator === '<' || c.operator === '<=') { |
|
lower = lowerLT(lt, c, options) |
|
if (lower === c && lower !== lt) { |
|
return false |
|
} |
|
} else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) { |
|
return false |
|
} |
|
} |
|
if (!c.operator && (lt || gt) && gtltComp !== 0) { |
|
return false |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
if (gt && hasDomLT && !lt && gtltComp !== 0) { |
|
return false |
|
} |
|
|
|
if (lt && hasDomGT && !gt && gtltComp !== 0) { |
|
return false |
|
} |
|
|
|
|
|
|
|
|
|
if (needDomGTPre || needDomLTPre) { |
|
return false |
|
} |
|
|
|
return true |
|
} |
|
|
|
|
|
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 |
|
} |
|
|
|
|
|
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 |
|
|