@npmcli/arborist 2.8.2 → 2.9.0

package/lib/optional-set.js

@@ -10,8 +10,9 @@
 
 const gatherDepSet = require('./gather-dep-set.js')
 const optionalSet = node => {
-  if (!node.optional)
+  if (!node.optional) {
     return new Set()
+  }
 
   // start with the node, then walk up the dependency graph until we
   // get to the boundaries that define the optional set.  since the
@@ -21,8 +22,9 @@ const optionalSet = node => {
   const set = new Set([node])
   for (const node of set) {
     for (const edge of node.edgesIn) {
-      if (!edge.optional)
+      if (!edge.optional) {
         set.add(edge.from)
+      }
     }
   }
 

package/lib/peer-entry-sets.js

@@ -15,12 +15,14 @@ const peerEntrySets = node => {
   const unionSet = new Set([node])
   for (const node of unionSet) {
     for (const edge of node.edgesOut.values()) {
-      if (edge.valid && edge.peer && edge.to)
+      if (edge.valid && edge.peer && edge.to) {
         unionSet.add(edge.to)
+      }
     }
     for (const edge of node.edgesIn) {
-      if (edge.valid && edge.peer)
+      if (edge.valid && edge.peer) {
         unionSet.add(edge.from)
+      }
     }
   }
   const entrySets = new Map()
@@ -28,16 +30,18 @@ const peerEntrySets = node => {
     for (const edge of peer.edgesIn) {
       // if not valid, it doesn't matter anyway.  either it's been previously
       // overridden, or it's the thing we're interested in replacing.
-      if (!edge.valid)
+      if (!edge.valid) {
         continue
+      }
       // this is the entry point into the peer set
       if (!edge.peer || edge.from.isTop) {
         // get the subset of peer brought in by this peer entry edge
         const sub = new Set([peer])
         for (const peer of sub) {
           for (const edge of peer.edgesOut.values()) {
-            if (edge.valid && edge.peer && edge.to)
+            if (edge.valid && edge.peer && edge.to) {
               sub.add(edge.to)
+            }
           }
         }
         // if this subset does not include the node we are focused on,
@@ -60,8 +64,9 @@ const peerEntrySets = node => {
         //     Edge(a->b) => Set(b, d, e, f, g)
         //     Edge(a->d) => Set(d, e, f, g)
         //   }
-        if (sub.has(node))
+        if (sub.has(node)) {
           entrySets.set(edge, sub)
+        }
       }
     }
   }

package/lib/place-dep.js

@@ -7,6 +7,7 @@
 // and saves a set of what was placed and what needs re-evaluation as
 // a result.
 
+const localeCompare = require('@isaacs/string-locale-compare')('en')
 const log = require('proc-log')
 const deepestNestingTarget = require('./deepest-nesting-target.js')
 const CanPlaceDep = require('./can-place-dep.js')
@@ -63,6 +64,8 @@ class PlaceDep {
     this.parent = parent
     this.peerConflict = null
 
+    this.needEvaluation = new Set()
+
     this.checks = new Map()
 
     this.place()
@@ -85,8 +88,9 @@ class PlaceDep {
         !edge.error &&
         !explicitRequest &&
         !updateNames.includes(edge.name) &&
-        !this.isVulnerable(edge.to))
+        !this.isVulnerable(edge.to)) {
       return
+    }
 
     // walk up the tree until we hit either a top/root node, or a place
     // where the dep is not a peer dep.
@@ -110,8 +114,9 @@ class PlaceDep {
       // but we CAN place it under a, so the correct thing to do is keep
       // walking up the tree.
       const targetEdge = target.edgesOut.get(edge.name)
-      if (!target.isTop && targetEdge && targetEdge.peer)
+      if (!target.isTop && targetEdge && targetEdge.peer) {
         continue
+      }
 
       const cpd = new CanPlaceDep({
         dep,
@@ -141,34 +146,39 @@ class PlaceDep {
       // should treat (b) and (d) as OK, and place them in the last place
       // where they did not themselves conflict, and skip c@2 if conflict
       // is ok by virtue of being forced or not ours and not strict.
-      if (cpd.canPlaceSelf !== CONFLICT)
+      if (cpd.canPlaceSelf !== CONFLICT) {
         canPlaceSelf = cpd
+      }
 
       // we found a place this can go, along with all its peer friends.
       // we break when we get the first conflict
-      if (cpd.canPlace !== CONFLICT)
+      if (cpd.canPlace !== CONFLICT) {
         canPlace = cpd
-      else
+      } else {
         break
+      }
 
       // if it's a load failure, just plop it in the first place attempted,
       // since we're going to crash the build or prune it out anyway.
       // but, this will frequently NOT be a successful canPlace, because
       // it'll have no version or other information.
-      if (dep.errors.length)
+      if (dep.errors.length) {
         break
+      }
 
       // nest packages like npm v1 and v2
       // very disk-inefficient
-      if (legacyBundling)
+      if (legacyBundling) {
         break
+      }
 
       // when installing globally, or just in global style, we never place
       // deps above the first level.
       if (globalStyle) {
         const rp = target.resolveParent
-        if (rp && rp.isProjectRoot)
+        if (rp && rp.isProjectRoot) {
           break
+        }
       }
     }
 
@@ -183,8 +193,9 @@ class PlaceDep {
     if (!canPlace) {
       // if not forced, or it's our dep, or strictPeerDeps is set, then
       // this is an ERESOLVE error.
-      if (!this.conflictOk)
+      if (!this.conflictOk) {
         return this.failPeerConflict()
+      }
 
       // ok!  we're gonna allow the conflict, but we should still warn
       // if we have a current, then we treat CONFLICT as a KEEP.
@@ -237,8 +248,9 @@ class PlaceDep {
     // it's a conflict.  Treat it as a KEEP, but warn and move on.
     if (placementType === KEEP) {
       // this was an overridden peer dep
-      if (edge.peer && !edge.valid)
+      if (edge.peer && !edge.valid) {
         this.warnPeerConflict()
+      }
 
       // if we get a KEEP in a update scenario, then we MAY have something
       // already duplicating this unnecessarily!  For example:
@@ -287,21 +299,24 @@ class PlaceDep {
     })
 
     this.oldDep = target.children.get(this.name)
-    if (this.oldDep)
+    if (this.oldDep) {
       this.replaceOldDep()
-    else
+    } else {
       this.placed.parent = target
+    }
 
     // if it's an overridden peer dep, warn about it
-    if (edge.peer && !this.placed.satisfies(edge))
+    if (edge.peer && !this.placed.satisfies(edge)) {
       this.warnPeerConflict()
+    }
 
     // If the edge is not an error, then we're updating something, and
     // MAY end up putting a better/identical node further up the tree in
     // a way that causes an unnecessary duplication.  If so, remove the
     // now-unnecessary node.
-    if (edge.valid && edge.to && edge.to !== this.placed)
+    if (edge.valid && edge.to && edge.to !== this.placed) {
       this.pruneDedupable(edge.to, false)
+    }
 
     // in case we just made some duplicates that can be removed,
     // prune anything deeper in the tree that can be replaced by this
@@ -310,8 +325,9 @@ class PlaceDep {
         this.pruneDedupable(node, false)
         // only walk the direct children of the ones we kept
         if (node.root === target.root) {
-          for (const kid of node.children.values())
+          for (const kid of node.children.values()) {
             this.pruneDedupable(kid, false)
+          }
         }
       }
     }
@@ -323,8 +339,9 @@ class PlaceDep {
     // otherwise they'd be gone and the peer set would change throughout
     // this loop.
     for (const peerEdge of this.placed.edgesOut.values()) {
-      if (peerEdge.valid || !peerEdge.peer || peerEdge.overridden)
+      if (peerEdge.valid || !peerEdge.peer || peerEdge.overridden) {
         continue
+      }
 
       const peer = virtualRoot.children.get(peerEdge.name)
 
@@ -332,12 +349,14 @@ class PlaceDep {
       // it's an optional peer dep.  If it's not being properly met (ie,
       // peerEdge.valid is false), then this is likely heading for an
       // ERESOLVE error, unless it can walk further up the tree.
-      if (!peer)
+      if (!peer) {
         continue
+      }
 
       // overridden peerEdge, just accept what's there already
-      if (!peer.satisfies(peerEdge))
+      if (!peer.satisfies(peerEdge)) {
         continue
+      }
 
       this.children.push(new PlaceDep({
         parent: this,
@@ -349,6 +368,8 @@ class PlaceDep {
   }
 
   replaceOldDep () {
+    const target = this.oldDep.parent
+
     // XXX handle replacing an entire peer group?
     // what about cases where we need to push some other peer groups deeper
     // into the tree?  all the tree updating should be done here, and track
@@ -363,11 +384,51 @@ class PlaceDep {
     // later anyway.
     const oldDeps = []
     for (const [name, edge] of this.oldDep.edgesOut.entries()) {
-      if (!this.placed.edgesOut.has(name) && edge.to)
+      if (!this.placed.edgesOut.has(name) && edge.to) {
         oldDeps.push(...gatherDepSet([edge.to], e => e.to !== edge.to))
+      }
     }
+
+    // gather all peer edgesIn which are at this level, and will not be
+    // satisfied by the new dependency.  Those are the peer sets that need
+    // to be either warned about (if they cannot go deeper), or removed and
+    // re-placed (if they can).
+    const prunePeerSets = []
+    for (const edge of this.oldDep.edgesIn) {
+      if (this.placed.satisfies(edge) ||
+          !edge.peer ||
+          edge.from.parent !== target ||
+          edge.overridden) {
+        // not a peer dep, not invalid, or not from this level, so it's fine
+        // to just let it re-evaluate as a problemEdge later, or let it be
+        // satisfied by the new dep being placed.
+        continue
+      }
+      for (const entryEdge of peerEntrySets(edge.from).keys()) {
+        // either this one needs to be pruned and re-evaluated, or marked
+        // as overridden and warned about.  If the entryEdge comes in from
+        // the root, then we have to leave it alone, and in that case, it
+        // will have already warned or crashed by getting to this point.
+        const entryNode = entryEdge.to
+        const deepestTarget = deepestNestingTarget(entryNode)
+        if (deepestTarget !== target && !entryEdge.from.isRoot) {
+          prunePeerSets.push(...gatherDepSet([entryNode], e => {
+            return e.to !== entryNode && !e.overridden
+          }))
+        } else {
+          this.warnPeerConflict(edge, this.dep)
+        }
+      }
+    }
+
     this.placed.replace(this.oldDep)
     this.pruneForReplacement(this.placed, oldDeps)
+    for (const dep of prunePeerSets) {
+      for (const edge of dep.edgesIn) {
+        this.needEvaluation.add(edge.from)
+      }
+      dep.root = null
+    }
   }
 
   pruneForReplacement (node, oldDeps) {
@@ -377,8 +438,9 @@ class PlaceDep {
       .filter(e => e.to && !e.valid).map(e => e.to))
     for (const dep of oldDeps) {
       const set = gatherDepSet([dep], e => e.to !== dep && e.valid)
-      for (const dep of set)
+      for (const dep of set) {
         invalidDeps.add(dep)
+      }
     }
 
     // ignore dependency edges from the node being replaced, but
@@ -388,8 +450,9 @@ class PlaceDep {
       edge.from !== node && edge.to !== node && edge.valid)
 
     // now just delete whatever's left, because it's junk
-    for (const dep of deps)
+    for (const dep of deps) {
       dep.root = null
+    }
   }
 
   // prune all the nodes in a branch of the tree that can be safely removed
@@ -402,24 +465,27 @@ class PlaceDep {
       // the dep set, except for this node we're deduping, so that we
       // also prune deps that would be made extraneous.
       const deps = gatherDepSet([node], e => e.to !== node && e.valid)
-      for (const node of deps)
+      for (const node of deps) {
         node.root = null
+      }
       return
     }
     if (descend) {
       // sort these so that they're deterministically ordered
       // otherwise, resulting tree shape is dependent on the order
       // in which they happened to be resolved.
-      const nodeSort = (a, b) => a.location.localeCompare(b.location, 'en')
+      const nodeSort = (a, b) => localeCompare(a.location, b.location)
 
       const children = [...node.children.values()].sort(nodeSort)
-      for (const child of children)
+      for (const child of children) {
         this.pruneDedupable(child)
+      }
       const fsChildren = [...node.fsChildren].sort(nodeSort)
       for (const topNode of fsChildren) {
         const children = [...topNode.children.values()].sort(nodeSort)
-        for (const child of children)
+        for (const child of children) {
           this.pruneDedupable(child)
+        }
       }
     }
   }
@@ -432,11 +498,13 @@ class PlaceDep {
     const { edge } = this.top
     const { from: node } = edge
 
-    if (node.isWorkspace || node.isProjectRoot)
+    if (node.isWorkspace || node.isProjectRoot) {
       return true
+    }
 
-    if (!edge.peer)
+    if (!edge.peer) {
       return false
+    }
 
     // re-entry case.  check if any non-peer edges come from the project,
     // or any entryEdges on peer groups are from the root.
@@ -446,32 +514,37 @@ class PlaceDep {
         hasPeerEdges = true
         continue
       }
-      if (edge.from.isWorkspace || edge.from.isProjectRoot)
+      if (edge.from.isWorkspace || edge.from.isProjectRoot) {
         return true
+      }
     }
     if (hasPeerEdges) {
       for (const edge of peerEntrySets(node).keys()) {
-        if (edge.from.isWorkspace || edge.from.isProjectRoot)
+        if (edge.from.isWorkspace || edge.from.isProjectRoot) {
           return true
+        }
       }
     }
 
     return false
   }
 
-  warnPeerConflict () {
-    this.edge.overridden = true
-    const expl = this.explainPeerConflict()
+  warnPeerConflict (edge, dep) {
+    edge = edge || this.edge
+    dep = dep || this.dep
+    edge.overridden = true
+    const expl = this.explainPeerConflict(edge, dep)
     log.warn('ERESOLVE', 'overriding peer dependency', expl)
   }
 
-  failPeerConflict () {
-    const expl = this.explainPeerConflict()
+  failPeerConflict (edge, dep) {
+    edge = edge || this.top.edge
+    dep = dep || this.top.dep
+    const expl = this.explainPeerConflict(edge, dep)
     throw Object.assign(new Error('could not resolve'), expl)
   }
 
-  explainPeerConflict () {
-    const { edge, dep } = this.top
+  explainPeerConflict (edge, dep) {
     const { from: node } = edge
     const curNode = node.resolve(edge.name)
 
@@ -541,8 +614,9 @@ class PlaceDep {
   get allChildren () {
     const set = new Set(this.children)
     for (const child of set) {
-      for (const grandchild of child.children)
+      for (const grandchild of child.children) {
         set.add(grandchild)
+      }
     }
     return [...set]
   }

package/lib/printable.js

@@ -1,63 +1,81 @@
 // helper function to output a clearer visualization
 // of the current node and its descendents
 
+const localeCompare = require('@isaacs/string-locale-compare')('en')
 const util = require('util')
 const relpath = require('./relpath.js')
 
 class ArboristNode {
   constructor (tree, path) {
     this.name = tree.name
-    if (tree.packageName && tree.packageName !== this.name)
+    if (tree.packageName && tree.packageName !== this.name) {
       this.packageName = tree.packageName
-    if (tree.version)
+    }
+    if (tree.version) {
       this.version = tree.version
+    }
     this.location = tree.location
     this.path = tree.path
-    if (tree.realpath !== this.path)
+    if (tree.realpath !== this.path) {
       this.realpath = tree.realpath
-    if (tree.resolved !== null)
+    }
+    if (tree.resolved !== null) {
       this.resolved = tree.resolved
-    if (tree.extraneous)
+    }
+    if (tree.extraneous) {
       this.extraneous = true
-    if (tree.dev)
+    }
+    if (tree.dev) {
       this.dev = true
-    if (tree.optional)
+    }
+    if (tree.optional) {
       this.optional = true
-    if (tree.devOptional && !tree.dev && !tree.optional)
+    }
+    if (tree.devOptional && !tree.dev && !tree.optional) {
       this.devOptional = true
-    if (tree.peer)
+    }
+    if (tree.peer) {
       this.peer = true
-    if (tree.inBundle)
+    }
+    if (tree.inBundle) {
       this.bundled = true
-    if (tree.inDepBundle)
+    }
+    if (tree.inDepBundle) {
       this.bundler = tree.getBundler().location
-    if (tree.isProjectRoot)
+    }
+    if (tree.isProjectRoot) {
       this.isProjectRoot = true
-    if (tree.isWorkspace)
+    }
+    if (tree.isWorkspace) {
       this.isWorkspace = true
+    }
     const bd = tree.package && tree.package.bundleDependencies
-    if (bd && bd.length)
+    if (bd && bd.length) {
       this.bundleDependencies = bd
-    if (tree.inShrinkwrap)
+    }
+    if (tree.inShrinkwrap) {
       this.inShrinkwrap = true
-    else if (tree.hasShrinkwrap)
+    } else if (tree.hasShrinkwrap) {
       this.hasShrinkwrap = true
-    if (tree.error)
+    }
+    if (tree.error) {
       this.error = treeError(tree.error)
-    if (tree.errors && tree.errors.length)
+    }
+    if (tree.errors && tree.errors.length) {
       this.errors = tree.errors.map(treeError)
+    }
 
     // edgesOut sorted by name
     if (tree.edgesOut.size) {
       this.edgesOut = new Map([...tree.edgesOut.entries()]
-        .sort(([a], [b]) => a.localeCompare(b, 'en'))
+        .sort(([a], [b]) => localeCompare(a, b))
         .map(([name, edge]) => [name, new EdgeOut(edge)]))
     }
 
     // edgesIn sorted by location
     if (tree.edgesIn.size) {
       this.edgesIn = new Set([...tree.edgesIn]
-        .sort((a, b) => a.from.location.localeCompare(b.from.location, 'en'))
+        .sort((a, b) => localeCompare(a.from.location, b.from.location))
         .map(edge => new EdgeIn(edge)))
     }
 
@@ -69,14 +87,14 @@ class ArboristNode {
     // fsChildren sorted by path
     if (tree.fsChildren.size) {
       this.fsChildren = new Set([...tree.fsChildren]
-        .sort(({path: a}, {path: b}) => a.localeCompare(b, 'en'))
+        .sort(({path: a}, {path: b}) => localeCompare(a, b))
         .map(tree => printableTree(tree, path)))
     }
 
     // children sorted by name
     if (tree.children.size) {
       this.children = new Map([...tree.children.entries()]
-        .sort(([a], [b]) => a.localeCompare(b, 'en'))
+        .sort(([a], [b]) => localeCompare(a, b))
         .map(([name, tree]) => [name, printableTree(tree, path)]))
     }
   }
@@ -109,10 +127,12 @@ class Edge {
     this.type = edge.type
     this.name = edge.name
     this.spec = edge.spec || '*'
-    if (edge.error)
+    if (edge.error) {
       this.error = edge.error
-    if (edge.overridden)
+    }
+    if (edge.overridden) {
       this.overridden = edge.overridden
+    }
   }
 }
 
@@ -151,8 +171,9 @@ class EdgeIn extends Edge {
 }
 
 const printableTree = (tree, path = []) => {
-  if (!tree)
+  if (!tree) {
     return tree
+  }
 
   const Cls = tree.isLink ? ArboristLink
     : tree.sourceReference ? ArboristVirtualNode

package/lib/realpath.js

@@ -14,18 +14,21 @@ const { resolve, basename, dirname } = require('path')
 const realpathCached = (path, rpcache, stcache, depth) => {
   // just a safety against extremely deep eloops
   /* istanbul ignore next */
-  if (depth > 2000)
+  if (depth > 2000) {
     throw eloop(path)
+  }
 
   path = resolve(path)
-  if (rpcache.has(path))
+  if (rpcache.has(path)) {
     return Promise.resolve(rpcache.get(path))
+  }
 
   const dir = dirname(path)
   const base = basename(path)
 
-  if (base && rpcache.has(dir))
+  if (base && rpcache.has(dir)) {
     return realpathChild(dir, base, rpcache, stcache, depth)
+  }
 
   // if it's the root, then we know it's real
   if (!base) {
@@ -40,8 +43,9 @@ const realpathCached = (path, rpcache, stcache, depth) => {
 }
 
 const lstatCached = (path, stcache) => {
-  if (stcache.has(path))
+  if (stcache.has(path)) {
     return Promise.resolve(stcache.get(path))
+  }
 
   const p = lstat(path).then(st => {
     stcache.set(path, st)
@@ -66,8 +70,9 @@ const realpathChild = (dir, base, rpcache, stcache, depth) => {
   const realdir = rpcache.get(dir)
   // that unpossible
   /* istanbul ignore next */
-  if (typeof realdir === 'undefined')
+  if (typeof realdir === 'undefined') {
     throw new Error('in realpathChild without parent being in realpath cache')
+  }
 
   const realish = resolve(realdir, base)
   return lstatCached(realish, stcache).then(st => {
@@ -78,8 +83,9 @@ const realpathChild = (dir, base, rpcache, stcache, depth) => {
 
     return readlink(realish).then(target => {
       const resolved = resolve(realdir, target)
-      if (realish === resolved)
+      if (realish === resolved) {
         throw eloop(realish)
+      }
 
       return realpathCached(resolved, rpcache, stcache, depth + 1)
     }).then(real => {