@npmcli/arborist 6.2.7 → 6.2.9

package/lib/edge.js

@@ -4,194 +4,210 @@
 const util = require('util')
 const npa = require('npm-package-arg')
 const depValid = require('./dep-valid.js')
-const _from = Symbol('_from')
-const _to = Symbol('_to')
-const _type = Symbol('_type')
-const _spec = Symbol('_spec')
-const _accept = Symbol('_accept')
-const _name = Symbol('_name')
-const _error = Symbol('_error')
-const _loadError = Symbol('_loadError')
-const _setFrom = Symbol('_setFrom')
-const _explain = Symbol('_explain')
-const _explanation = Symbol('_explanation')
-
-const types = new Set([
-  'prod',
-  'dev',
-  'optional',
-  'peer',
-  'peerOptional',
-  'workspace',
-])
-
-class ArboristEdge {}
-const printableEdge = (edge) => {
-  const edgeFrom = edge.from && edge.from.location
-  const edgeTo = edge.to && edge.to.location
-  const override = edge.overrides && edge.overrides.value
-
-  return Object.assign(new ArboristEdge(), {
-    name: edge.name,
-    spec: edge.spec,
-    type: edge.type,
-    ...(edgeFrom != null ? { from: edgeFrom } : {}),
-    ...(edgeTo ? { to: edgeTo } : {}),
-    ...(edge.error ? { error: edge.error } : {}),
-    ...(edge.peerConflicted ? { peerConflicted: true } : {}),
-    ...(override ? { overridden: override } : {}),
-  })
+
+class ArboristEdge {
+  constructor (edge) {
+    this.name = edge.name
+    this.spec = edge.spec
+    this.type = edge.type
+
+    const edgeFrom = edge.from?.location
+    const edgeTo = edge.to?.location
+    const override = edge.overrides?.value
+
+    if (edgeFrom != null) {
+      this.from = edgeFrom
+    }
+    if (edgeTo) {
+      this.to = edgeTo
+    }
+    if (edge.error) {
+      this.error = edge.error
+    }
+    if (edge.peerConflicted) {
+      this.peerConflicted = true
+    }
+    if (override) {
+      this.overridden = override
+    }
+  }
 }
 
 class Edge {
+  #accept
+  #error
+  #explanation
+  #from
+  #name
+  #spec
+  #to
+  #type
+
+  static types = Object.freeze([
+    'prod',
+    'dev',
+    'optional',
+    'peer',
+    'peerOptional',
+    'workspace',
+  ])
+
+  // XXX where is this used?
+  static errors = Object.freeze([
+    'DETACHED',
+    'MISSING',
+    'PEER LOCAL',
+    'INVALID',
+  ])
+
   constructor (options) {
     const { type, name, spec, accept, from, overrides } = options
 
+    // XXX are all of these error states even possible?
     if (typeof spec !== 'string') {
       throw new TypeError('must provide string spec')
     }
-
+    if (!Edge.types.includes(type)) {
+      throw new TypeError(`invalid type: ${type}\n(valid types are: ${Edge.types.join(', ')})`)
+    }
     if (type === 'workspace' && npa(spec).type !== 'directory') {
       throw new TypeError('workspace edges must be a symlink')
     }
-
-    this[_spec] = spec
-
-    if (overrides !== undefined) {
-      this.overrides = overrides
+    if (typeof name !== 'string') {
+      throw new TypeError('must provide dependency name')
+    }
+    if (!from) {
+      throw new TypeError('must provide "from" node')
     }
-
     if (accept !== undefined) {
       if (typeof accept !== 'string') {
         throw new TypeError('accept field must be a string if provided')
       }
-      this[_accept] = accept || '*'
+      this.#accept = accept || '*'
     }
-
-    if (typeof name !== 'string') {
-      throw new TypeError('must provide dependency name')
+    if (overrides !== undefined) {
+      this.overrides = overrides
     }
-    this[_name] = name
 
-    if (!types.has(type)) {
-      throw new TypeError(
-        `invalid type: ${type}\n` +
-        `(valid types are: ${Edge.types.join(', ')})`)
-    }
-    this[_type] = type
-    if (!from) {
-      throw new TypeError('must provide "from" node')
-    }
-    this[_setFrom](from)
-    this[_error] = this[_loadError]()
+    this.#name = name
+    this.#type = type
+    this.#spec = spec
+    this.#explanation = null
+    this.#from = from
+
+    from.edgesOut.get(this.#name)?.detach()
+    from.addEdgeOut(this)
+
+    this.reload(true)
     this.peerConflicted = false
   }
 
   satisfiedBy (node) {
-    if (node.name !== this.name) {
+    if (node.name !== this.#name) {
       return false
     }
 
     // NOTE: this condition means we explicitly do not support overriding
     // bundled or shrinkwrapped dependencies
-    const spec = (node.hasShrinkwrap || node.inShrinkwrap || node.inBundle)
-      ? this.rawSpec
-      : this.spec
-    return depValid(node, spec, this.accept, this.from)
-  }
-
-  explain (seen = []) {
-    if (this[_explanation]) {
-      return this[_explanation]
+    if (node.hasShrinkwrap || node.inShrinkwrap || node.inBundle) {
+      return depValid(node, this.rawSpec, this.#accept, this.#from)
     }
-
-    return this[_explanation] = this[_explain](seen)
+    return depValid(node, this.spec, this.#accept, this.#from)
   }
 
   // return the edge data, and an explanation of how that edge came to be here
-  [_explain] (seen) {
-    const { error, from, bundled } = this
-    return {
-      type: this.type,
-      name: this.name,
-      spec: this.spec,
-      ...(this.rawSpec !== this.spec ? {
-        rawSpec: this.rawSpec,
-        overridden: true,
-      } : {}),
-      ...(bundled ? { bundled } : {}),
-      ...(error ? { error } : {}),
-      ...(from ? { from: from.explain(null, seen) } : {}),
+  explain (seen = []) {
+    if (!this.#explanation) {
+      const explanation = {
+        type: this.#type,
+        name: this.#name,
+        spec: this.spec,
+      }
+      if (this.rawSpec !== this.spec) {
+        explanation.rawSpec = this.rawSpec
+        explanation.overridden = true
+      }
+      if (this.bundled) {
+        explanation.bundled = this.bundled
+      }
+      if (this.error) {
+        explanation.error = this.error
+      }
+      if (this.#from) {
+        explanation.from = this.#from.explain(null, seen)
+      }
+      this.#explanation = explanation
     }
+    return this.#explanation
   }
 
   get bundled () {
-    if (!this.from) {
-      return false
-    }
-    const { package: { bundleDependencies = [] } } = this.from
-    return bundleDependencies.includes(this.name)
+    return !!this.#from?.package?.bundleDependencies?.includes(this.#name)
   }
 
   get workspace () {
-    return this[_type] === 'workspace'
+    return this.#type === 'workspace'
   }
 
   get prod () {
-    return this[_type] === 'prod'
+    return this.#type === 'prod'
   }
 
   get dev () {
-    return this[_type] === 'dev'
+    return this.#type === 'dev'
   }
 
   get optional () {
-    return this[_type] === 'optional' || this[_type] === 'peerOptional'
+    return this.#type === 'optional' || this.#type === 'peerOptional'
   }
 
   get peer () {
-    return this[_type] === 'peer' || this[_type] === 'peerOptional'
+    return this.#type === 'peer' || this.#type === 'peerOptional'
   }
 
   get type () {
-    return this[_type]
+    return this.#type
   }
 
   get name () {
-    return this[_name]
+    return this.#name
   }
 
   get rawSpec () {
-    return this[_spec]
+    return this.#spec
   }
 
   get spec () {
-    if (this.overrides?.value && this.overrides.value !== '*' && this.overrides.name === this.name) {
+    if (this.overrides?.value && this.overrides.value !== '*' && this.overrides.name === this.#name) {
       if (this.overrides.value.startsWith('$')) {
         const ref = this.overrides.value.slice(1)
         // we may be a virtual root, if we are we want to resolve reference overrides
         // from the real root, not the virtual one
-        const pkg = this.from.sourceReference
-          ? this.from.sourceReference.root.package
-          : this.from.root.package
-        const overrideSpec = (pkg.devDependencies && pkg.devDependencies[ref]) ||
-            (pkg.optionalDependencies && pkg.optionalDependencies[ref]) ||
-            (pkg.dependencies && pkg.dependencies[ref]) ||
-            (pkg.peerDependencies && pkg.peerDependencies[ref])
-
-        if (overrideSpec) {
-          return overrideSpec
+        const pkg = this.#from.sourceReference
+          ? this.#from.sourceReference.root.package
+          : this.#from.root.package
+        if (pkg.devDependencies?.[ref]) {
+          return pkg.devDependencies[ref]
+        }
+        if (pkg.optionalDependencies?.[ref]) {
+          return pkg.optionalDependencies[ref]
+        }
+        if (pkg.dependencies?.[ref]) {
+          return pkg.dependencies[ref]
+        }
+        if (pkg.peerDependencies?.[ref]) {
+          return pkg.peerDependencies[ref]
         }
 
         throw new Error(`Unable to resolve reference ${this.overrides.value}`)
       }
       return this.overrides.value
     }
-    return this[_spec]
+    return this.#spec
   }
 
   get accept () {
-    return this[_accept]
+    return this.#accept
   }
 
   get valid () {
@@ -211,71 +227,70 @@ class Edge {
   }
 
   get error () {
-    this[_error] = this[_error] || this[_loadError]()
-    return this[_error] === 'OK' ? null : this[_error]
-  }
-
-  [_loadError] () {
-    return !this[_to] ? (this.optional ? null : 'MISSING')
-      : this.peer && this.from === this.to.parent && !this.from.isTop ? 'PEER LOCAL'
-      : !this.satisfiedBy(this.to) ? 'INVALID'
-      : 'OK'
+    if (!this.#error) {
+      if (!this.#to) {
+        if (this.optional) {
+          this.#error = null
+        } else {
+          this.#error = 'MISSING'
+        }
+      } else if (this.peer && this.#from === this.#to.parent && !this.#from.isTop) {
+        this.#error = 'PEER LOCAL'
+      } else if (!this.satisfiedBy(this.#to)) {
+        this.#error = 'INVALID'
+      } else {
+        this.#error = 'OK'
+      }
+    }
+    if (this.#error === 'OK') {
+      return null
+    }
+    return this.#error
   }
 
   reload (hard = false) {
-    this[_explanation] = null
-    if (this[_from].overrides) {
-      this.overrides = this[_from].overrides.getEdgeRule(this)
+    this.#explanation = null
+    if (this.#from.overrides) {
+      this.overrides = this.#from.overrides.getEdgeRule(this)
     } else {
       delete this.overrides
     }
-    const newTo = this[_from].resolve(this.name)
-    if (newTo !== this[_to]) {
-      if (this[_to]) {
-        this[_to].edgesIn.delete(this)
+    const newTo = this.#from.resolve(this.#name)
+    if (newTo !== this.#to) {
+      if (this.#to) {
+        this.#to.edgesIn.delete(this)
       }
-      this[_to] = newTo
-      this[_error] = this[_loadError]()
-      if (this[_to]) {
-        this[_to].addEdgeIn(this)
+      this.#to = newTo
+      this.#error = null
+      if (this.#to) {
+        this.#to.addEdgeIn(this)
       }
     } else if (hard) {
-      this[_error] = this[_loadError]()
+      this.#error = null
     }
   }
 
   detach () {
-    this[_explanation] = null
-    if (this[_to]) {
-      this[_to].edgesIn.delete(this)
+    this.#explanation = null
+    if (this.#to) {
+      this.#to.edgesIn.delete(this)
     }
-    this[_from].edgesOut.delete(this.name)
-    this[_to] = null
-    this[_error] = 'DETACHED'
-    this[_from] = null
-  }
-
-  [_setFrom] (node) {
-    this[_explanation] = null
-    this[_from] = node
-    if (node.edgesOut.has(this.name)) {
-      node.edgesOut.get(this.name).detach()
-    }
-
-    node.addEdgeOut(this)
-    this.reload()
+    this.#from.edgesOut.delete(this.#name)
+    this.#to = null
+    this.#error = 'DETACHED'
+    this.#from = null
   }
 
   get from () {
-    return this[_from]
+    return this.#from
   }
 
   get to () {
-    return this[_to]
+    return this.#to
   }
 
   toJSON () {
-    return printableEdge(this)
+    return new ArboristEdge(this)
   }
 
   [util.inspect.custom] () {
@@ -283,12 +298,4 @@ class Edge {
   }
 }
 
-Edge.types = [...types]
-Edge.errors = [
-  'DETACHED',
-  'MISSING',
-  'PEER LOCAL',
-  'INVALID',
-]
-
 module.exports = Edge

package/lib/from-path.js

@@ -1,24 +1,30 @@
-// file dependencies need their dependencies resolved based on the
-// location where the tarball was found, not the location where they
-// end up getting installed.  directory (ie, symlink) deps also need
-// to be resolved based on their targets, but that's what realpath is
+// file dependencies need their dependencies resolved based on the location
+// where the tarball was found, not the location where they end up getting
+// installed.  directory (ie, symlink) deps also need to be resolved based on
+// their targets, but that's what realpath is
 
 const { dirname } = require('path')
 const npa = require('npm-package-arg')
 
-const fromPath = (node, spec, edge) => {
+const fromPath = (node, edge) => {
   if (edge && edge.overrides && edge.overrides.name === edge.name && edge.overrides.value) {
-    // fromPath could be called with a node that has a virtual root, if that happens
-    // we want to make sure we get the real root node when overrides are in use. this
-    // is to allow things like overriding a dependency with a tarball file that's a
-    // relative path from the project root
-    return node.sourceReference
-      ? node.sourceReference.root.realpath
-      : node.root.realpath
+    // fromPath could be called with a node that has a virtual root, if that
+    // happens we want to make sure we get the real root node when overrides
+    // are in use. this is to allow things like overriding a dependency with a
+    // tarball file that's a relative path from the project root
+    if (node.sourceReference) {
+      return node.sourceReference.root.realpath
+    }
+    return node.root.realpath
   }
 
-  return spec && spec.type === 'file' ? dirname(spec.fetchSpec)
-    : node.realpath
+  if (node.resolved) {
+    const spec = npa(node.resolved)
+    if (spec?.type === 'file') {
+      return dirname(spec.fetchSpec)
+    }
+  }
+  return node.realpath
 }
 
-module.exports = (node, edge) => fromPath(node, node.resolved && npa(node.resolved), edge)
+module.exports = fromPath

package/lib/inventory.js

@@ -1,45 +1,28 @@
-// a class to manage an inventory and set of indexes of
-// a set of objects based on specific fields.
-// primary is the primary index key.
-// keys is the set of fields to be able to query.
-const _primaryKey = Symbol('_primaryKey')
-const _index = Symbol('_index')
-const defaultKeys = ['name', 'license', 'funding', 'realpath', 'packageName']
+// a class to manage an inventory and set of indexes of a set of objects based
+// on specific fields.
 const { hasOwnProperty } = Object.prototype
 const debug = require('./debug.js')
 
-// handling for the outdated "licenses" array, just pick the first one
-// also support the alternative spelling "licence"
-const getLicense = pkg => {
-  if (pkg) {
-    const lic = pkg.license || pkg.licence
-    if (lic) {
-      return lic
-    }
-    const lics = pkg.licenses || pkg.licences
-    if (Array.isArray(lics)) {
-      return lics[0]
-    }
-  }
-}
-
+const keys = ['name', 'license', 'funding', 'realpath', 'packageName']
 class Inventory extends Map {
-  constructor (opt = {}) {
-    const { primary, keys } = opt
+  #index
+
+  constructor () {
     super()
-    this[_primaryKey] = primary || 'location'
-    this[_index] = (keys || defaultKeys).reduce((index, i) => {
-      index.set(i, new Map())
-      return index
-    }, new Map())
+    this.#index = new Map()
+    for (const key of keys) {
+      this.#index.set(key, new Map())
+    }
   }
 
+  // XXX where is this used?
   get primaryKey () {
-    return this[_primaryKey]
+    return 'location'
   }
 
+  // XXX where is this used?
   get indexes () {
-    return [...this[_index].keys()]
+    return [...keys]
   }
 
   * filter (fn) {
@@ -63,28 +46,49 @@ class Inventory extends Map {
       return
     }
 
-    const current = super.get(node[this.primaryKey])
+    const current = super.get(node.location)
     if (current) {
       if (current === node) {
         return
       }
       this.delete(current)
     }
-    super.set(node[this.primaryKey], node)
-    for (const [key, map] of this[_index].entries()) {
-      // if the node has the value, but it's false, then use that
-      const val_ = hasOwnProperty.call(node, key) ? node[key]
-        : key === 'license' ? getLicense(node.package)
-        : node[key] ? node[key]
-        : node.package && node.package[key]
-      const val = typeof val_ === 'string' ? val_
-        : !val_ || typeof val_ !== 'object' ? val_
-        : key === 'license' ? val_.type
-        : key === 'funding' ? val_.url
-        : /* istanbul ignore next - not used */ val_
-      const set = map.get(val) || new Set()
-      set.add(node)
-      map.set(val, set)
+    super.set(node.location, node)
+    for (const [key, map] of this.#index.entries()) {
+      let val
+      if (hasOwnProperty.call(node, key)) {
+        // if the node has the value, use it even if it's false
+        val = node[key]
+      } else if (key === 'license' && node.package) {
+        // handling for the outdated "licenses" array, just pick the first one
+        // also support the alternative spelling "licence"
+        if (node.package.license) {
+          val = node.package.license
+        } else if (node.package.licence) {
+          val = node.package.licence
+        } else if (Array.isArray(node.package.licenses)) {
+          val = node.package.licenses[0]
+        } else if (Array.isArray(node.package.licences)) {
+          val = node.package.licences[0]
+        }
+      } else if (node[key]) {
+        val = node[key]
+      } else {
+        val = node.package?.[key]
+      }
+      if (val && typeof val === 'object') {
+        // We currently only use license and funding
+        /* istanbul ignore next - not used */
+        if (key === 'license') {
+          val = val.type
+        } else if (key === 'funding') {
+          val = val.url
+        }
+      }
+      if (!map.has(val)) {
+        map.set(val, new Set())
+      }
+      map.get(val).add(node)
     }
   }
 
@@ -93,10 +97,14 @@ class Inventory extends Map {
       return
     }
 
-    super.delete(node[this.primaryKey])
-    for (const [key, map] of this[_index].entries()) {
-      const val = node[key] !== undefined ? node[key]
-        : (node[key] || (node.package && node.package[key]))
+    super.delete(node.location)
+    for (const [key, map] of this.#index.entries()) {
+      let val
+      if (node[key] !== undefined) {
+        val = node[key]
+      } else {
+        val = node.package?.[key]
+      }
       const set = map.get(val)
       if (set) {
         set.delete(node)
@@ -108,13 +116,18 @@ class Inventory extends Map {
   }
 
   query (key, val) {
-    const map = this[_index].get(key)
-    return map && (arguments.length === 2 ? map.get(val) : map.keys()) ||
-      new Set()
+    const map = this.#index.get(key)
+    if (arguments.length === 2) {
+      if (map.has(val)) {
+        return map.get(val)
+      }
+      return new Set()
+    }
+    return map.keys()
   }
 
   has (node) {
-    return super.get(node[this.primaryKey]) === node
+    return super.get(node.location) === node
   }
 
   set (k, v) {