@npmcli/arborist 2.8.2 → 2.9.0

package/lib/diff.js

@@ -31,7 +31,12 @@ class Diff {
     this.removed = []
   }
 
-  static calculate ({actual, ideal, filterNodes = [], shrinkwrapInflated = new Set()}) {
+  static calculate ({
+    actual,
+    ideal,
+    filterNodes = [],
+    shrinkwrapInflated = new Set(),
+  }) {
     // if there's a filterNode, then:
     // - get the path from the root to the filterNode.  The root or
     //   root.target should have an edge either to the filterNode or
@@ -43,8 +48,9 @@ class Diff {
     const extraneous = new Set()
     for (const filterNode of filterNodes) {
       const { root } = filterNode
-      if (root !== ideal && root !== actual)
+      if (root !== ideal && root !== actual) {
         throw new Error('invalid filterNode: outside idealTree/actualTree')
+      }
       const rootTarget = root.target
       const edge = [...rootTarget.edgesOut.values()].filter(e => {
         return e.to && (e.to === filterNode || e.to.target === filterNode)
@@ -73,8 +79,9 @@ class Diff {
             : [...actualNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
           if (actualNode) {
             for (const child of actualNode.children.values()) {
-              if (child.extraneous)
+              if (child.extraneous) {
                 extraneous.add(child)
+              }
             }
           }
 
@@ -82,8 +89,9 @@ class Diff {
         },
       })
     }
-    for (const extra of extraneous)
+    for (const extra of extraneous) {
       filterSet.add(extra)
+    }
 
     return depth({
       tree: new Diff({actual, ideal, filterSet, shrinkwrapInflated}),
@@ -94,23 +102,27 @@ class Diff {
 }
 
 const getAction = ({actual, ideal}) => {
-  if (!ideal)
+  if (!ideal) {
     return 'REMOVE'
+  }
 
   // bundled meta-deps are copied over to the ideal tree when we visit it,
   // so they'll appear to be missing here.  There's no need to handle them
   // in the diff, though, because they'll be replaced at reify time anyway
   // Otherwise, add the missing node.
-  if (!actual)
+  if (!actual) {
     return ideal.inDepBundle ? null : 'ADD'
+  }
 
   // always ignore the root node
-  if (ideal.isRoot && actual.isRoot)
+  if (ideal.isRoot && actual.isRoot) {
     return null
+  }
 
   // if the versions don't match, it's a change no matter what
-  if (ideal.version !== actual.version)
+  if (ideal.version !== actual.version) {
     return 'CHANGE'
+  }
 
   const binsExist = ideal.binPaths.every((path) => existsSync(path))
 
@@ -125,33 +137,38 @@ const getAction = ({actual, ideal}) => {
   const noIntegrity = !ideal.integrity && !actual.integrity
   const noResolved = !ideal.resolved && !actual.resolved
   const resolvedMatch = ideal.resolved && ideal.resolved === actual.resolved
-  if (noIntegrity && binsExist && (resolvedMatch || noResolved))
+  if (noIntegrity && binsExist && (resolvedMatch || noResolved)) {
     return null
+  }
 
   // otherwise, verify that it's the same bits
   // note that if ideal has integrity, and resolved doesn't, we treat
   // that as a 'change', so that it gets re-fetched and locked down.
   const integrityMismatch = !ideal.integrity || !actual.integrity ||
     !ssri.parse(ideal.integrity).match(actual.integrity)
-  if (integrityMismatch || !binsExist)
+  if (integrityMismatch || !binsExist) {
     return 'CHANGE'
+  }
 
   return null
 }
 
 const allChildren = node => {
-  if (!node)
+  if (!node) {
     return new Map()
+  }
 
   // if the node is root, and also a link, then what we really
   // want is to traverse the target's children
-  if (node.isRoot && node.isLink)
+  if (node.isRoot && node.isLink) {
     return allChildren(node.target)
+  }
 
   const kids = new Map()
   for (const n of [node, ...node.fsChildren]) {
-    for (const kid of n.children.values())
+    for (const kid of n.children.values()) {
       kids.set(kid.path, kid)
+    }
   }
   return kids
 }
@@ -160,7 +177,14 @@ const allChildren = node => {
 // to create the diff tree
 const getChildren = diff => {
   const children = []
-  const {actual, ideal, unchanged, removed, filterSet, shrinkwrapInflated} = diff
+  const {
+    actual,
+    ideal,
+    unchanged,
+    removed,
+    filterSet,
+    shrinkwrapInflated,
+  } = diff
 
   // Note: we DON'T diff fsChildren themselves, because they are either
   // included in the package contents, or part of some other project, and
@@ -182,26 +206,45 @@ const getChildren = diff => {
   for (const path of paths) {
     const actual = actualKids.get(path)
     const ideal = idealKids.get(path)
-    diffNode(actual, ideal, children, unchanged, removed, filterSet, shrinkwrapInflated)
+    diffNode({
+      actual,
+      ideal,
+      children,
+      unchanged,
+      removed,
+      filterSet,
+      shrinkwrapInflated,
+    })
   }
 
-  if (diff.leaves && !children.length)
+  if (diff.leaves && !children.length) {
     diff.leaves.push(diff)
+  }
 
   return children
 }
 
-const diffNode = (actual, ideal, children, unchanged, removed, filterSet, shrinkwrapInflated) => {
-  if (filterSet.size && !(filterSet.has(ideal) || filterSet.has(actual)))
+const diffNode = ({
+  actual,
+  ideal,
+  children,
+  unchanged,
+  removed,
+  filterSet,
+  shrinkwrapInflated,
+}) => {
+  if (filterSet.size && !(filterSet.has(ideal) || filterSet.has(actual))) {
     return
+  }
 
   const action = getAction({actual, ideal})
 
   // if it's a match, then get its children
   // otherwise, this is the child diff node
   if (action || (!shrinkwrapInflated.has(ideal) && ideal.hasShrinkwrap)) {
-    if (action === 'REMOVE')
+    if (action === 'REMOVE') {
       removed.push(actual)
+    }
     children.push(new Diff({actual, ideal, filterSet, shrinkwrapInflated}))
   } else {
     unchanged.push(ideal)
@@ -227,13 +270,22 @@ const diffNode = (actual, ideal, children, unchanged, removed, filterSet, shrink
     if (actual && bd && bd.length) {
       const bundledChildren = []
       for (const node of actual.children.values()) {
-        if (node.inBundle)
+        if (node.inBundle) {
           bundledChildren.push(node)
+        }
       }
-      for (const node of bundledChildren)
+      for (const node of bundledChildren) {
         node.parent = ideal
+      }
     }
-    children.push(...getChildren({actual, ideal, unchanged, removed, filterSet, shrinkwrapInflated}))
+    children.push(...getChildren({
+      actual,
+      ideal,
+      unchanged,
+      removed,
+      filterSet,
+      shrinkwrapInflated,
+    }))
   }
 }
 

package/lib/edge.js

@@ -45,22 +45,26 @@ class Edge {
   constructor (options) {
     const { type, name, spec, accept, from } = options
 
-    if (typeof spec !== 'string')
+    if (typeof spec !== 'string') {
       throw new TypeError('must provide string spec')
+    }
 
-    if (type === 'workspace' && npa(spec).type !== 'directory')
+    if (type === 'workspace' && npa(spec).type !== 'directory') {
       throw new TypeError('workspace edges must be a symlink')
+    }
 
     this[_spec] = spec
 
     if (accept !== undefined) {
-      if (typeof accept !== 'string')
+      if (typeof accept !== 'string') {
         throw new TypeError('accept field must be a string if provided')
+      }
       this[_accept] = accept || '*'
     }
 
-    if (typeof name !== 'string')
+    if (typeof name !== 'string') {
       throw new TypeError('must provide dependency name')
+    }
     this[_name] = name
 
     if (!types.has(type)) {
@@ -69,20 +73,23 @@ class Edge {
         `(valid types are: ${Edge.types.join(', ')})`)
     }
     this[_type] = type
-    if (!from)
+    if (!from) {
       throw new TypeError('must provide "from" node')
+    }
     this[_setFrom](from)
     this[_error] = this[_loadError]()
     this.overridden = false
   }
 
   satisfiedBy (node) {
-    return node.name === this.name && depValid(node, this.spec, this.accept, this.from)
+    return node.name === this.name &&
+      depValid(node, this.spec, this.accept, this.from)
   }
 
   explain (seen = []) {
-    if (this[_explanation])
+    if (this[_explanation]) {
       return this[_explanation]
+    }
 
     return this[_explanation] = this[_explain](seen)
   }
@@ -101,8 +108,9 @@ class Edge {
   }
 
   get bundled () {
-    if (!this.from)
+    if (!this.from) {
       return false
+    }
     const { package: { bundleDependencies = [] } } = this.from
     return bundleDependencies.includes(this.name)
   }
@@ -175,20 +183,24 @@ class Edge {
     this[_explanation] = null
     const newTo = this[_from].resolve(this.name)
     if (newTo !== this[_to]) {
-      if (this[_to])
+      if (this[_to]) {
         this[_to].edgesIn.delete(this)
+      }
       this[_to] = newTo
       this[_error] = this[_loadError]()
-      if (this[_to])
+      if (this[_to]) {
         this[_to].addEdgeIn(this)
-    } else if (hard)
+      }
+    } else if (hard) {
       this[_error] = this[_loadError]()
+    }
   }
 
   detach () {
     this[_explanation] = null
-    if (this[_to])
+    if (this[_to]) {
       this[_to].edgesIn.delete(this)
+    }
     this[_from].edgesOut.delete(this.name)
     this[_to] = null
     this[_error] = 'DETACHED'
@@ -198,8 +210,9 @@ class Edge {
   [_setFrom] (node) {
     this[_explanation] = null
     this[_from] = node
-    if (node.edgesOut.has(this.name))
+    if (node.edgesOut.has(this.name)) {
       node.edgesOut.get(this.name).detach()
+    }
     node.addEdgeOut(this)
     this.reload()
   }

package/lib/gather-dep-set.js

@@ -14,8 +14,9 @@ const gatherDepSet = (set, edgeFilter) => {
   // as the deps set increases in size.
   for (const node of deps) {
     for (const edge of node.edgesOut.values()) {
-      if (edge.to && edgeFilter(edge))
+      if (edge.to && edgeFilter(edge)) {
         deps.add(edge.to)
+      }
     }
   }
 

package/lib/inventory.js

@@ -13,11 +13,13 @@ const debug = require('./debug.js')
 const getLicense = pkg => {
   if (pkg) {
     const lic = pkg.license || pkg.licence
-    if (lic)
+    if (lic) {
       return lic
+    }
     const lics = pkg.licenses || pkg.licences
-    if (Array.isArray(lics))
+    if (Array.isArray(lics)) {
       return lics[0]
+    }
   }
 }
 
@@ -42,8 +44,9 @@ class Inventory extends Map {
 
   * filter (fn) {
     for (const node of this.values()) {
-      if (fn(node))
+      if (fn(node)) {
         yield node
+      }
     }
   }
 
@@ -62,8 +65,9 @@ class Inventory extends Map {
 
     const current = super.get(node[this.primaryKey])
     if (current) {
-      if (current === node)
+      if (current === node) {
         return
+      }
       this.delete(current)
     }
     super.set(node[this.primaryKey], node)
@@ -85,8 +89,9 @@ class Inventory extends Map {
   }
 
   delete (node) {
-    if (!this.has(node))
+    if (!this.has(node)) {
       return
+    }
 
     super.delete(node[this.primaryKey])
     for (const [key, map] of this[_index].entries()) {
@@ -95,8 +100,9 @@ class Inventory extends Map {
       const set = map.get(val)
       if (set) {
         set.delete(node)
-        if (set.size === 0)
+        if (set.size === 0) {
           map.delete(node[key])
+        }
       }
     }
   }

package/lib/link.js

@@ -11,8 +11,9 @@ class Link extends Node {
   constructor (options) {
     const { root, realpath, target, parent, fsParent } = options
 
-    if (!realpath && !(target && target.path))
+    if (!realpath && !(target && target.path)) {
       throw new TypeError('must provide realpath for Link node')
+    }
 
     super({
       ...options,
@@ -23,11 +24,11 @@ class Link extends Node {
       : null),
     })
 
-    if (target)
+    if (target) {
       this.target = target
-    else if (this.realpath === this.root.path)
+    } else if (this.realpath === this.root.path) {
       this.target = this.root
-    else {
+    } else {
       this.target = new Node({
         ...options,
         path: realpath,
@@ -48,8 +49,9 @@ class Link extends Node {
 
   set target (target) {
     const current = this[_target]
-    if (target === current)
+    if (target === current) {
       return
+    }
 
     if (current && current.then) {
       debug(() => {
@@ -72,25 +74,28 @@ class Link extends Node {
     }
 
     if (!target) {
-      if (current && current.linksIn)
+      if (current && current.linksIn) {
         current.linksIn.delete(this)
+      }
       if (this.path) {
         this[_delistFromMeta]()
         this[_target] = null
         this.package = {}
         this[_refreshLocation]()
-      } else
+      } else {
         this[_target] = null
+      }
       return
     }
 
     if (!this.path) {
       // temp node pending assignment to a tree
       // we know it's not in the inventory yet, because no path.
-      if (target.path)
+      if (target.path) {
         this.realpath = target.path
-      else
+      } else {
         target.path = target.realpath = this.realpath
+      }
       target.root = this.root
       this[_target] = target
       target.linksIn.add(this)