@npmcli/arborist 2.7.1 → 2.8.3

package/lib/arborist/deduper.js

@@ -6,8 +6,9 @@ module.exports = cls => class Deduper extends cls {
     const tree = await this.loadVirtual().catch(() => this.loadActual())
     const names = []
     for (const name of tree.inventory.query('name')) {
-      if (tree.inventory.query('name', name).size > 1)
+      if (tree.inventory.query('name', name).size > 1) {
         names.push(name)
+      }
     }
     return this.reify({
       ...options,

package/lib/arborist/index.js

@@ -59,8 +59,9 @@ class Arborist extends Base {
       packumentCache: options.packumentCache || new Map(),
       log: options.log || procLog,
     }
-    if (options.saveType && !saveTypeMap.get(options.saveType))
+    if (options.saveType && !saveTypeMap.get(options.saveType)) {
       throw new Error(`Invalid saveType ${options.saveType}`)
+    }
     this.cache = resolve(this.options.cache)
     this.path = resolve(this.options.path)
     process.emit('timeEnd', 'arborist:ctor')
@@ -81,17 +82,20 @@ class Arborist extends Base {
         const dep = edge.to
         if (dep) {
           set.add(dep)
-          if (dep.isLink)
+          if (dep.isLink) {
             set.add(dep.target)
+          }
         }
       }
       for (const child of node.children.values()) {
-        if (child.extraneous)
+        if (child.extraneous) {
           extraneous.add(child)
+        }
       }
     }
-    for (const extra of extraneous)
+    for (const extra of extraneous) {
       set.add(extra)
+    }
     return set
   }
 }

package/lib/arborist/load-actual.js

@@ -78,8 +78,9 @@ module.exports = cls => class ActualLoader extends cls {
   [_resetDepFlags] (tree, root) {
     // reset all deps to extraneous prior to recalc
     if (!root) {
-      for (const node of tree.inventory.values())
+      for (const node of tree.inventory.values()) {
         node.extraneous = true
+      }
     }
 
     // only reset root flags if we're not re-rooting,
@@ -176,8 +177,9 @@ module.exports = cls => class ActualLoader extends cls {
     await this[_loadFSTree](this[_actualTree])
     await this[_loadWorkspaces](this[_actualTree])
     await this[_loadWorkspaceTargets](this[_actualTree])
-    if (!ignoreMissing)
+    if (!ignoreMissing) {
       await this[_findMissingEdges]()
+    }
     this[_findFSParents]()
     this[_transplant](root)
 
@@ -188,8 +190,10 @@ module.exports = cls => class ActualLoader extends cls {
       const tree = this[_actualTree]
       const actualRoot = tree.isLink ? tree.target : tree
       const { dependencies = {} } = actualRoot.package
-      for (const name of actualRoot.children.keys())
-        dependencies[name] = dependencies[name] || '*'
+      for (const [name, kid] of actualRoot.children.entries()) {
+        const def = kid.isLink ? `file:${kid.realpath}` : '*'
+        dependencies[name] = dependencies[name] || def
+      }
       actualRoot.package = { ...actualRoot.package, dependencies }
     }
     return this[_actualTree]
@@ -198,8 +202,9 @@ module.exports = cls => class ActualLoader extends cls {
   // if there are workspace targets without Link nodes created, load
   // the targets, so that we know what they are.
   async [_loadWorkspaceTargets] (tree) {
-    if (!tree.workspaces || !tree.workspaces.size)
+    if (!tree.workspaces || !tree.workspaces.size) {
       return
+    }
 
     const promises = []
     for (const path of tree.workspaces.values()) {
@@ -213,18 +218,21 @@ module.exports = cls => class ActualLoader extends cls {
   }
 
   [_transplant] (root) {
-    if (!root || root === this[_actualTree])
+    if (!root || root === this[_actualTree]) {
       return
+    }
 
     this[_actualTree][_changePath](root.path)
     for (const node of this[_actualTree].children.values()) {
-      if (!this[_transplantFilter](node))
+      if (!this[_transplantFilter](node)) {
         node.root = null
+      }
     }
 
     root.replace(this[_actualTree])
-    for (const node of this[_actualTree].fsChildren)
+    for (const node of this[_actualTree].fsChildren) {
       node.root = this[_transplantFilter](node) ? root : null
+    }
 
     this[_actualTree] = root
   }
@@ -289,8 +297,9 @@ module.exports = cls => class ActualLoader extends cls {
     // it'll get parented later, making the fsParent scan a no-op, but better
     // safe than sorry, since it's cheap.
     const { parent, realpath } = options
-    if (!parent)
+    if (!parent) {
       this[_topNodes].add(realpath)
+    }
     return process.env._TEST_ARBORIST_SLOW_LINK_TARGET_ === '1'
       ? new Promise(res => setTimeout(() => res(new Node(options)), 100))
       : new Node(options)
@@ -307,8 +316,9 @@ module.exports = cls => class ActualLoader extends cls {
       // if a link target points at a node outside of the root tree's
       // node_modules hierarchy, then load that node as well.
       return this[_loadFSTree](link.target).then(() => link)
-    } else if (target.then)
+    } else if (target.then) {
       target.then(node => link.target = node)
+    }
 
     return link
   }
@@ -319,13 +329,15 @@ module.exports = cls => class ActualLoader extends cls {
 
     // if a Link target has started, but not completed, then
     // a Promise will be in the cache to indicate this.
-    if (node.then)
+    if (node.then) {
       return node.then(node => this[_loadFSTree](node))
+    }
 
     // impossible except in pathological ELOOP cases
     /* istanbul ignore if */
-    if (did.has(node.realpath))
+    if (did.has(node.realpath)) {
       return Promise.resolve(node)
+    }
 
     did.add(node.realpath)
     return this[_loadFSChildren](node)
@@ -369,8 +381,11 @@ module.exports = cls => class ActualLoader extends cls {
 
       const depPromises = []
       for (const [name, edge] of node.edgesOut.entries()) {
-        if (!edge.missing && !(edge.to && (edge.to.dummy || edge.to.parent !== node)))
+        const notMissing = !edge.missing &&
+          !(edge.to && (edge.to.dummy || edge.to.parent !== node))
+        if (notMissing) {
           continue
+        }
 
         // start the walk from the dirname, because we would have found
         // the dep in the loadFSTree step already if it was local.
@@ -381,14 +396,16 @@ module.exports = cls => class ActualLoader extends cls {
           // allows for finding the transitive deps of link targets.
           // ie, if it has to go up and back out to get to the path
           // from the nearest common ancestor, we've gone too far.
-          if (ancestor && /^\.\.(?:[\\/]|$)/.test(relative(ancestor, p)))
+          if (ancestor && /^\.\.(?:[\\/]|$)/.test(relative(ancestor, p))) {
             break
+          }
 
           const entries = nmContents.get(p) ||
             await readdir(p + '/node_modules').catch(() => [])
           nmContents.set(p, entries)
-          if (!entries.includes(name))
+          if (!entries.includes(name)) {
             continue
+          }
 
           const d = this[_cache].has(p) ? await this[_cache].get(p)
             : new Node({ path: p, root: node.root, dummy: true })

package/lib/arborist/load-virtual.js

@@ -40,8 +40,9 @@ module.exports = cls => class VirtualLoader extends cls {
 
   // public method
   async loadVirtual (options = {}) {
-    if (this.virtualTree)
+    if (this.virtualTree) {
       return this.virtualTree
+    }
 
     // allow the user to set reify options on the ctor as well.
     // XXX: deprecate separate reify() options object.
@@ -85,18 +86,21 @@ module.exports = cls => class VirtualLoader extends cls {
       root.optional = false
       root.devOptional = false
       root.peer = false
-    } else
+    } else {
       this[flagsSuspect] = true
+    }
 
     this[checkRootEdges](s, root)
     root.meta = s
     this.virtualTree = root
     const {links, nodes} = this[resolveNodes](s, root)
     await this[resolveLinks](links, nodes)
-    if (!(s.originalLockfileVersion >= 2))
+    if (!(s.originalLockfileVersion >= 2)) {
       this[assignBundles](nodes)
-    if (this[flagsSuspect])
+    }
+    if (this[flagsSuspect]) {
       this[reCalcDepFlags](nodes.values())
+    }
     return root
   }
 
@@ -104,8 +108,9 @@ module.exports = cls => class VirtualLoader extends cls {
     // reset all dep flags
     // can't use inventory here, because virtualTree might not be root
     for (const node of nodes) {
-      if (node.isRoot || node === this[rootOptionProvided])
+      if (node.isRoot || node === this[rootOptionProvided]) {
         continue
+      }
       node.extraneous = true
       node.dev = true
       node.optional = true
@@ -123,8 +128,9 @@ module.exports = cls => class VirtualLoader extends cls {
     // loaded virtually from tree, no chance of being out of sync
     // ancient lockfiles are critically damaged by this process,
     // so we need to just hope for the best in those cases.
-    if (!s.loadedFromDisk || s.ancientLockfile)
+    if (!s.loadedFromDisk || s.ancientLockfile) {
       return
+    }
 
     const lock = s.get('')
     const prod = lock.dependencies || {}
@@ -140,16 +146,18 @@ module.exports = cls => class VirtualLoader extends cls {
         }
       }
     }
-    for (const name of Object.keys(optional))
+    for (const name of Object.keys(optional)) {
       delete prod[name]
+    }
 
     const lockWS = []
     const workspaces = this[loadWorkspacesVirtual]({
       cwd: this.path,
       lockfile: s.data,
     })
-    for (const [name, path] of workspaces.entries())
+    for (const [name, path] of workspaces.entries()) {
       lockWS.push(['workspace', name, `file:${path}`])
+    }
 
     const lockEdges = [
       ...depsToEdges('prod', prod),
@@ -174,8 +182,9 @@ module.exports = cls => class VirtualLoader extends cls {
     for (let i = 0; i < lockEdges.length; i++) {
       if (rootEdges[i][0] !== lockEdges[i][0] ||
           rootEdges[i][1] !== lockEdges[i][1] ||
-          rootEdges[i][2] !== lockEdges[i][2])
+          rootEdges[i][2] !== lockEdges[i][2]) {
         return this[flagsSuspect] = true
+      }
     }
   }
 
@@ -185,13 +194,15 @@ module.exports = cls => class VirtualLoader extends cls {
     const nodes = new Map([['', root]])
     for (const [location, meta] of Object.entries(s.data.packages)) {
       // skip the root because we already got it
-      if (!location)
+      if (!location) {
         continue
+      }
 
-      if (meta.link)
+      if (meta.link) {
         links.set(location, meta)
-      else
+      } else {
         nodes.set(location, this[loadNode](location, meta))
+      }
     }
     return {links, nodes}
   }
@@ -212,8 +223,9 @@ module.exports = cls => class VirtualLoader extends cls {
       if (!link.target.parent) {
         const pj = link.realpath + '/package.json'
         const pkg = await rpj(pj).catch(() => null)
-        if (pkg)
+        if (pkg) {
           link.target.package = pkg
+        }
       }
     }
   }
@@ -221,12 +233,14 @@ module.exports = cls => class VirtualLoader extends cls {
   [assignBundles] (nodes) {
     for (const [location, node] of nodes) {
       // Skip assignment of parentage for the root package
-      if (!location || node.isLink && !node.target.location)
+      if (!location || node.isLink && !node.target.location) {
         continue
+      }
       const { name, parent, package: { inBundle }} = node
 
-      if (!parent)
+      if (!parent) {
         continue
+      }
 
       // read inBundle from package because 'package' here is
       // actually a v2 lockfile metadata entry.
@@ -236,10 +250,11 @@ module.exports = cls => class VirtualLoader extends cls {
       const { package: ppkg } = parent
       const { inBundle: parentBundled } = ppkg
       if (inBundle && !parentBundled && parent.edgesOut.has(node.name)) {
-        if (!ppkg.bundleDependencies)
+        if (!ppkg.bundleDependencies) {
           ppkg.bundleDependencies = [name]
-        else
+        } else {
           ppkg.bundleDependencies.push(name)
+        }
       }
     }
   }
@@ -248,8 +263,9 @@ module.exports = cls => class VirtualLoader extends cls {
     const p = this.virtualTree ? this.virtualTree.realpath : this.path
     const path = resolve(p, location)
     // shrinkwrap doesn't include package name unless necessary
-    if (!sw.name)
+    if (!sw.name) {
       sw.name = nameFromFolder(path)
+    }
 
     const dev = sw.dev
     const optional = sw.optional

package/lib/arborist/load-workspaces.js

@@ -7,15 +7,17 @@ const _loadWorkspacesVirtual = Symbol.for('loadWorkspacesVirtual')
 
 module.exports = cls => class MapWorkspaces extends cls {
   [_appendWorkspaces] (node, workspaces) {
-    if (node && workspaces.size)
+    if (node && workspaces.size) {
       node.workspaces = workspaces
+    }
 
     return node
   }
 
   async [_loadWorkspaces] (node) {
-    if (node.workspaces)
+    if (node.workspaces) {
       return node
+    }
 
     const workspaces = await mapWorkspaces({
       cwd: node.path,

package/lib/arborist/rebuild.js

@@ -61,8 +61,9 @@ module.exports = cls => class Builder extends cls {
 
   async rebuild ({ nodes, handleOptionalFailure = false } = {}) {
     // nothing to do if we're not building anything!
-    if (this[_ignoreScripts] && !this[_binLinks])
+    if (this[_ignoreScripts] && !this[_binLinks]) {
       return
+    }
 
     // when building for the first time, as part of reify, we ignore
     // failures in optional nodes, and just delete them.  however, when
@@ -76,8 +77,9 @@ module.exports = cls => class Builder extends cls {
       if (this[_workspaces] && this[_workspaces].length) {
         const filterSet = this.workspaceDependencySet(tree, this[_workspaces])
         nodes = tree.inventory.filter(node => filterSet.has(node))
-      } else
+      } else {
         nodes = tree.inventory.values()
+      }
     }
 
     // separates links nodes so that it can run
@@ -88,10 +90,11 @@ module.exports = cls => class Builder extends cls {
     for (const node of nodes) {
       // we skip the target nodes to that workspace in order to make sure
       // we only run lifecycle scripts / place bin links once per workspace
-      if (node.isLink)
+      if (node.isLink) {
         linkNodes.add(node)
-      else
+      } else {
         depNodes.add(node)
+      }
     }
 
     await this[_build](depNodes, {})
@@ -118,17 +121,20 @@ module.exports = cls => class Builder extends cls {
     process.emit('time', `build:${type}`)
 
     await this[_buildQueues](nodes)
-    if (!this[_ignoreScripts])
+    if (!this[_ignoreScripts]) {
       await this[_runScripts]('preinstall')
-    if (this[_binLinks] && type !== 'links')
+    }
+    if (this[_binLinks] && type !== 'links') {
       await this[_linkAllBins]()
+    }
 
     // links should also run prepare scripts and only link bins after that
     if (type === 'links') {
       await this[_runScripts]('prepare')
 
-      if (this[_binLinks])
+      if (this[_binLinks]) {
         await this[_linkAllBins]()
+      }
     }
 
     if (!this[_ignoreScripts]) {
@@ -173,8 +179,9 @@ module.exports = cls => class Builder extends cls {
       const { preinstall, install, postinstall, prepare } = scripts
       const tests = { bin, preinstall, install, postinstall, prepare }
       for (const [key, has] of Object.entries(tests)) {
-        if (has)
+        if (has) {
           this[_queues][key].push(node)
+        }
       }
     }
     process.emit('timeEnd', 'build:queue')
@@ -186,15 +193,17 @@ module.exports = cls => class Builder extends cls {
     // the node path.  Otherwise a package can have a preinstall script
     // that unlinks something, to allow them to silently overwrite system
     // binaries, which is unsafe and insecure.
-    if (!node.globalTop || this[_force])
+    if (!node.globalTop || this[_force]) {
       return
+    }
     const { path, package: pkg } = node
     await binLinks.checkBins({ pkg, path, top: true, global: true })
   }
 
   async [_addToBuildSet] (node, set, refreshed = false) {
-    if (set.has(node))
+    if (set.has(node)) {
       return
+    }
 
     if (this[_oldMeta] === null) {
       const {root: {meta}} = node
@@ -233,8 +242,9 @@ module.exports = cls => class Builder extends cls {
       await isNodeGypPackage(node.path)
 
     if (bin || preinstall || install || postinstall || prepare || isGyp) {
-      if (bin)
+      if (bin) {
         await this[_checkBins](node)
+      }
       if (isGyp) {
         scripts.install = defaultGypInstallScript
         node.package.scripts = scripts
@@ -246,8 +256,9 @@ module.exports = cls => class Builder extends cls {
   async [_runScripts] (event) {
     const queue = this[_queues][event]
 
-    if (!queue.length)
+    if (!queue.length) {
       return
+    }
 
     process.emit('time', `build:run:${event}`)
     const stdio = this.options.foregroundScripts ? 'inherit' : 'pipe'
@@ -266,8 +277,9 @@ module.exports = cls => class Builder extends cls {
       } = node.target
 
       // skip any that we know we'll be deleting
-      if (this[_trashList].has(path))
+      if (this[_trashList].has(path)) {
         return
+      }
 
       const timer = `build:run:${event}:${location}`
       process.emit('time', timer)
@@ -321,23 +333,26 @@ module.exports = cls => class Builder extends cls {
 
   async [_linkAllBins] () {
     const queue = this[_queues].bin
-    if (!queue.length)
+    if (!queue.length) {
       return
+    }
 
     process.emit('time', 'build:link')
     const promises = []
     // sort the queue by node path, so that the module-local collision
     // detector in bin-links will always resolve the same way.
-    for (const node of queue.sort(sortNodes))
+    for (const node of queue.sort(sortNodes)) {
       promises.push(this[_createBinLinks](node))
+    }
 
     await promiseAllRejectLate(promises)
     process.emit('timeEnd', 'build:link')
   }
 
   async [_createBinLinks] (node) {
-    if (this[_trashList].has(node.path))
+    if (this[_trashList].has(node.path)) {
       return
+    }
 
     process.emit('time', `build:link:${node.location}`)