npm-packlist 2.2.2 → 5.0.0

package/bin/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+'use strict'
+
+const packlist = require('../')
 
 const dirs = []
 let doSort = false
@@ -6,20 +9,31 @@ process.argv.slice(2).forEach(arg => {
   if (arg === '-h' || arg === '--help') {
     console.log('usage: npm-packlist [-s --sort] [directory, directory, ...]')
     process.exit(0)
-  } else if (arg === '-s' || arg === '--sort')
+  } else if (arg === '-s' || arg === '--sort') {
     doSort = true
-  else
+  } else {
     dirs.push(arg)
+  }
 })
 
 const sort = list => doSort ? list.sort((a, b) => a.localeCompare(b, 'en')) : list
 
-const packlist = require('../')
-if (!dirs.length)
-  console.log(sort(packlist.sync({ path: process.cwd() })).join('\n'))
-else {
-  dirs.forEach(path => {
-    console.log(`> ${path}`)
-    console.log(sort(packlist.sync({ path })).join('\n'))
-  })
+const main = async () => {
+  if (!dirs.length) {
+    const results = await packlist({ path: process.cwd() })
+    console.log(sort(results).join('\n'))
+  } else {
+    for (const dir of dirs) {
+      console.group(`> ${dir}`)
+      const results = await packlist({ path: dir })
+      console.log(sort(results).join('\n'))
+      console.groupEnd()
+    }
+  }
 }
+
+// coverage disabled for catch handler because we don't need to test that
+main().catch(/* istanbul ignore next */(err) => {
+  process.exitCode = 1
+  console.error(err.stack)
+})

package/{index.js → lib/index.js}

@@ -7,11 +7,9 @@
 
 const bundleWalk = require('npm-bundled')
 const BundleWalker = bundleWalk.BundleWalker
-const BundleWalkerSync = bundleWalk.BundleWalkerSync
 
 const ignoreWalk = require('ignore-walk')
 const IgnoreWalker = ignoreWalk.Walker
-const IgnoreWalkerSync = ignoreWalk.WalkerSync
 
 const rootBuiltinRules = Symbol('root-builtin-rules')
 const packageNecessaryRules = Symbol('package-necessary-rules')
@@ -34,6 +32,24 @@ const packageMustHavesRE = new RegExp(`^(${packageMustHaveFileNames})(\\..*[^~$]
 const fs = require('fs')
 const glob = require('glob')
 
+const pathHasPkg = (input) => {
+  if (!input.startsWith('node_modules/')) {
+    return false
+  }
+
+  const segments = input.slice('node_modules/'.length).split('/', 2)
+  return segments[0].startsWith('@')
+    ? segments.length === 2
+    : true
+}
+
+const pkgFromPath = (input) => {
+  const segments = input.slice('node_modules/'.length).split('/', 2)
+  return segments[0].startsWith('@')
+    ? segments.join('/')
+    : segments[0]
+}
+
 const defaultRules = [
   '.npmignore',
   '.gitignore',
@@ -58,14 +74,14 @@ const defaultRules = [
   '*.orig',
   '/package-lock.json',
   '/yarn.lock',
+  '/pnpm-lock.yaml',
   '/archived-packages/**',
 ]
 
 // There may be others, but :?|<> are handled by node-tar
 const nameIsBadForWindows = file => /\*/.test(file)
 
-// a decorator that applies our custom rules to an ignore walker
-const npmWalker = Class => class Walker extends Class {
+class Walker extends IgnoreWalker {
   constructor (opt) {
     opt = opt || {}
 
@@ -89,7 +105,7 @@ const npmWalker = Class => class Walker extends Class {
     // hierarchy (ie, not in test/foo/node_modules/ or something).
     const followRe = /^(?:\/node_modules\/(?:@[^/]+\/[^/]+|[^/]+)\/)*\/node_modules(?:\/@[^/]+)?$/
     const rootPath = opt.parent ? opt.parent.root : opt.path
-    const followTestPath = opt.path.replace(/\\/g, '/').substr(rootPath.length)
+    const followTestPath = opt.path.replace(/\\/g, '/').slice(rootPath.length)
     opt.follow = followRe.test(followTestPath)
 
     super(opt)
@@ -97,13 +113,14 @@ const npmWalker = Class => class Walker extends Class {
     // ignore a bunch of things by default at the root level.
     // also ignore anything in the main project node_modules hierarchy,
     // except bundled dependencies
-    if (!this.parent) {
+    if (this.isProject) {
       this.bundled = opt.bundled || []
       this.bundledScopes = Array.from(new Set(
         this.bundled.filter(f => /^@/.test(f))
           .map(f => f.split('/')[0])))
       const rules = defaultRules.join('\n') + '\n'
-      this.packageJsonCache = opt.packageJsonCache || new Map()
+      this.packageJsonCache = this.parent ? this.parent.packageJsonCache
+        : (opt.packageJsonCache || new Map())
       super.onReadIgnoreFile(rootBuiltinRules, rules, _ => _)
     } else {
       this.bundled = []
@@ -112,8 +129,12 @@ const npmWalker = Class => class Walker extends Class {
     }
   }
 
+  get isProject () {
+    return !this.parent || this.parent.follow && this.isSymbolicLink
+  }
+
   onReaddir (entries) {
-    if (!this.parent) {
+    if (this.isProject) {
       entries = entries.filter(e =>
         e !== '.git' &&
         !(e === 'node_modules' && this.bundled.length === 0)
@@ -126,8 +147,9 @@ const npmWalker = Class => class Walker extends Class {
     // to be in the state the user wants to include them, and
     // a package.json somewhere else might be a template or
     // test or something else entirely.
-    if (this.parent || !entries.includes('package.json'))
+    if (!this.isProject || !entries.includes('package.json')) {
       return super.onReaddir(entries)
+    }
 
     // when the cache has been seeded with the root manifest,
     // we must respect that (it may differ from the filesystem)
@@ -137,8 +159,9 @@ const npmWalker = Class => class Walker extends Class {
       const pkg = this.packageJsonCache.get(ig)
 
       // fall back to filesystem when seeded manifest is invalid
-      if (!pkg || typeof pkg !== 'object')
+      if (!pkg || typeof pkg !== 'object') {
         return this.readPackageJson(entries)
+      }
 
       // feels wonky, but this ensures package bin is _always_
       // normalized, as well as guarding against invalid JSON
@@ -149,22 +172,26 @@ const npmWalker = Class => class Walker extends Class {
   }
 
   onReadPackageJson (entries, er, pkg) {
-    if (er)
+    if (er) {
       this.emit('error', er)
-    else
+    } else {
       this.getPackageFiles(entries, pkg)
+    }
   }
 
   mustHaveFilesFromPackage (pkg) {
     const files = []
-    if (pkg.browser)
+    if (pkg.browser) {
       files.push('/' + pkg.browser)
-    if (pkg.main)
+    }
+    if (pkg.main) {
       files.push('/' + pkg.main)
+    }
     if (pkg.bin) {
       // always an object because normalized already
-      for (const key in pkg.bin)
+      for (const key in pkg.bin) {
         files.push('/' + pkg.bin[key])
+      }
     }
     files.push(
       '/package.json',
@@ -194,8 +221,9 @@ const npmWalker = Class => class Walker extends Class {
     this.packageJsonCache.set(ig, pkg)
 
     // no files list, just return the normal readdir() result
-    if (!Array.isArray(pkg.files))
+    if (!Array.isArray(pkg.files)) {
       return super.onReaddir(entries)
+    }
 
     pkg.files.push(...this.mustHaveFilesFromPackage(pkg))
 
@@ -204,13 +232,15 @@ const npmWalker = Class => class Walker extends Class {
     // the files list as the effective readdir result, that means it
     // looks like we don't have a node_modules folder at all unless we
     // include it here.
-    if ((pkg.bundleDependencies || pkg.bundledDependencies) && entries.includes('node_modules'))
+    if ((pkg.bundleDependencies || pkg.bundledDependencies) && entries.includes('node_modules')) {
       pkg.files.push('node_modules')
+    }
 
     const patterns = Array.from(new Set(pkg.files)).reduce((set, pattern) => {
       const excl = pattern.match(/^!+/)
-      if (excl)
-        pattern = pattern.substr(excl[0].length)
+      if (excl) {
+        pattern = pattern.slice(excl[0].length)
+      }
       // strip off any / from the start of the pattern.  /foo => foo
       pattern = pattern.replace(/^\/+/, '')
       // an odd number of ! means a negated pattern.  !!foo ==> foo
@@ -224,15 +254,17 @@ const npmWalker = Class => class Walker extends Class {
     const negates = new Set()
     const results = []
     const then = (pattern, negate, er, fileList, i) => {
-      if (er)
+      if (er) {
         return this.emit('error', er)
+      }
 
       results[i] = { negate, fileList }
-      if (--n === 0)
+      if (--n === 0) {
         processResults(results)
+      }
     }
-    const processResults = results => {
-      for (const {negate, fileList} of results) {
+    const processResults = processed => {
+      for (const { negate, fileList } of processed) {
         if (negate) {
           fileList.forEach(f => {
             f = f.replace(/\/+$/, '')
@@ -260,23 +292,23 @@ const npmWalker = Class => class Walker extends Class {
     // maintain the index so that we process them in-order only once all
     // are completed, otherwise the parallelism messes things up, since a
     // glob like **/*.js will always be slower than a subsequent !foo.js
-    patterns.forEach(({pattern, negate}, i) =>
+    patterns.forEach(({ pattern, negate }, i) =>
       this.globFiles(pattern, (er, res) => then(pattern, negate, er, res, i)))
   }
 
   filterEntry (entry, partial) {
     // get the partial path from the root of the walk
-    const p = this.path.substr(this.root.length + 1)
-    const pkgre = /^node_modules\/(@[^/]+\/?[^/]+|[^/]+)(\/.*)?$/
-    const isRoot = !this.parent
-    const pkg = isRoot && pkgre.test(entry) ?
-      entry.replace(pkgre, '$1') : null
-    const rootNM = isRoot && entry === 'node_modules'
-    const rootPJ = isRoot && entry === 'package.json'
+    const p = this.path.slice(this.root.length + 1)
+    const { isProject } = this
+    const pkg = isProject && pathHasPkg(entry)
+      ? pkgFromPath(entry)
+      : null
+    const rootNM = isProject && entry === 'node_modules'
+    const rootPJ = isProject && entry === 'package.json'
 
     return (
       // if we're in a bundled package, check with the parent.
-      /^node_modules($|\/)/i.test(p) ? this.parent.filterEntry(
+      /^node_modules($|\/)/i.test(p) && !this.isProject ? this.parent.filterEntry(
         this.basename + '/' + entry, partial)
 
       // if package is bundled, all files included
@@ -298,11 +330,11 @@ const npmWalker = Class => class Walker extends Class {
       : packageMustHavesRE.test(entry) ? true
 
       // npm-shrinkwrap and package.json always included in the root pkg
-      : isRoot && (entry === 'npm-shrinkwrap.json' || entry === 'package.json')
+      : isProject && (entry === 'npm-shrinkwrap.json' || entry === 'package.json')
         ? true
 
       // package-lock never included
-        : isRoot && entry === 'package-lock.json' ? false
+        : isProject && entry === 'package-lock.json' ? false
 
         // otherwise, follow ignore-walk's logic
         : super.filterEntry(entry, partial)
@@ -310,20 +342,22 @@ const npmWalker = Class => class Walker extends Class {
   }
 
   filterEntries () {
-    if (this.ignoreRules['.npmignore'])
+    if (this.ignoreRules['.npmignore']) {
       this.ignoreRules['.gitignore'] = null
+    }
     this.filterEntries = super.filterEntries
     super.filterEntries()
   }
 
   addIgnoreFile (file, then) {
     const ig = path.resolve(this.path, file)
-    if (file === 'package.json' && this.parent)
+    if (file === 'package.json' && !this.isProject) {
       then()
-    else if (this.packageJsonCache.has(ig))
+    } else if (this.packageJsonCache.has(ig)) {
       this.onPackageJson(ig, this.packageJsonCache.get(ig), then)
-    else
+    } else {
       super.addIgnoreFile(file, then)
+    }
   }
 
   onPackageJson (ig, pkg, then) {
@@ -347,19 +381,22 @@ const npmWalker = Class => class Walker extends Class {
   // override parent stat function to completely skip any filenames
   // that will break windows entirely.
   // XXX(isaacs) Next major version should make this an error instead.
-  stat (entry, file, dir, then) {
-    if (nameIsBadForWindows(entry))
+  stat ({ entry, file, dir }, then) {
+    if (nameIsBadForWindows(entry)) {
       then()
-    else
-      super.stat(entry, file, dir, then)
+    } else {
+      super.stat({ entry, file, dir }, then)
+    }
   }
 
-  // override parent onstat function to nix all symlinks
-  onstat (st, entry, file, dir, then) {
-    if (st.isSymbolicLink())
+  // override parent onstat function to nix all symlinks, other than
+  // those coming out of the followed bundled symlink deps
+  onstat ({ st, entry, file, dir, isSymbolicLink }, then) {
+    if (st.isSymbolicLink()) {
       then()
-    else
-      super.onstat(st, entry, file, dir, then)
+    } else {
+      super.onstat({ st, entry, file, dir, isSymbolicLink }, then)
+    }
   }
 
   onReadIgnoreFile (file, data, then) {
@@ -371,16 +408,25 @@ const npmWalker = Class => class Walker extends Class {
         // ignore package.json files that are not json
         then()
       }
-    } else
+    } else {
       super.onReadIgnoreFile(file, data, then)
+    }
   }
 
   sort (a, b) {
-    return sort(a, b)
+    // optimize for compressibility
+    // extname, then basename, then locale alphabetically
+    // https://twitter.com/isntitvacant/status/1131094910923231232
+    const exta = path.extname(a).toLowerCase()
+    const extb = path.extname(b).toLowerCase()
+    const basea = path.basename(a).toLowerCase()
+    const baseb = path.basename(b).toLowerCase()
+
+    return exta.localeCompare(extb, 'en') ||
+      basea.localeCompare(baseb, 'en') ||
+      a.localeCompare(b, 'en')
   }
-}
 
-class Walker extends npmWalker(IgnoreWalker) {
   globFiles (pattern, cb) {
     glob(pattern, { dot: true, cwd: this.path, nocase: true }, cb)
   }
@@ -390,28 +436,8 @@ class Walker extends npmWalker(IgnoreWalker) {
       this.onReadPackageJson(entries, er, pkg))
   }
 
-  walker (entry, then) {
-    new Walker(this.walkerOpt(entry)).on('done', then).start()
-  }
-}
-
-class WalkerSync extends npmWalker(IgnoreWalkerSync) {
-  globFiles (pattern, cb) {
-    cb(null, glob.sync(pattern, { dot: true, cwd: this.path, nocase: true }))
-  }
-
-  readPackageJson (entries) {
-    const p = this.path + '/package.json'
-    try {
-      this.onReadPackageJson(entries, null, fs.readFileSync(p))
-    } catch (er) {
-      this.onReadPackageJson(entries, er)
-    }
-  }
-
-  walker (entry, then) {
-    new WalkerSync(this.walkerOpt(entry)).start()
-    then()
+  walker (entry, opt, then) {
+    new Walker(this.walkerOpt(entry, opt)).on('done', then).start()
   }
 }
 
@@ -429,31 +455,5 @@ const walk = (options, callback) => {
   return callback ? p.then(res => callback(null, res), callback) : p
 }
 
-const walkSync = options => {
-  options = options || {}
-  const bw = new BundleWalkerSync(options).start()
-  options.bundled = bw.result
-  options.packageJsonCache = bw.packageJsonCache
-  const walker = new WalkerSync(options)
-  walker.start()
-  return walker.result
-}
-
-// optimize for compressibility
-// extname, then basename, then locale alphabetically
-// https://twitter.com/isntitvacant/status/1131094910923231232
-const sort = (a, b) => {
-  const exta = path.extname(a).toLowerCase()
-  const extb = path.extname(b).toLowerCase()
-  const basea = path.basename(a).toLowerCase()
-  const baseb = path.basename(b).toLowerCase()
-
-  return exta.localeCompare(extb, 'en') ||
-    basea.localeCompare(baseb, 'en') ||
-    a.localeCompare(b, 'en')
-}
-
 module.exports = walk
-walk.sync = walkSync
 walk.Walker = Walker
-walk.WalkerSync = WalkerSync

package/package.json

@@ -1,62 +1,61 @@
 {
   "name": "npm-packlist",
-  "version": "2.2.2",
+  "version": "5.0.0",
   "description": "Get a list of the files to add from a folder into an npm package",
   "directories": {
     "test": "test"
   },
-  "main": "index.js",
+  "main": "lib",
   "dependencies": {
-    "glob": "^7.1.6",
-    "ignore-walk": "^3.0.3",
-    "npm-bundled": "^1.1.1",
+    "glob": "^7.2.0",
+    "ignore-walk": "^5.0.1",
+    "npm-bundled": "^1.1.2",
     "npm-normalize-package-bin": "^1.0.1"
   },
-  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "author": "GitHub Inc.",
   "license": "ISC",
   "files": [
-    "bin/index.js",
-    "index.js"
+    "bin/",
+    "lib/"
   ],
   "devDependencies": {
-    "eslint": "^7.25.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
-    "eslint-plugin-standard": "^5.0.0",
+    "@npmcli/eslint-config": "^3.0.1",
+    "@npmcli/template-oss": "3.2.2",
     "mutate-fs": "^2.1.1",
-    "tap": "^15.0.6"
+    "tap": "^16.0.1"
   },
   "scripts": {
     "test": "tap",
     "posttest": "npm run lint",
     "snap": "tap",
-    "postsnap": "npm run lintfix",
+    "postsnap": "npm run lintfix --",
     "preversion": "npm test",
     "postversion": "npm publish",
     "prepublishOnly": "git push origin --follow-tags",
     "eslint": "eslint",
-    "lint": "npm run eslint -- index.js bin/index.js \"test/**/*.js\"",
-    "lintfix": "npm run lint -- --fix"
+    "lint": "eslint \"**/*.js\"",
+    "lintfix": "npm run lint -- --fix",
+    "npmclilint": "npmcli-lint",
+    "postlint": "template-oss-check",
+    "template-oss-apply": "template-oss-apply --force"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/npm/npm-packlist.git"
+    "url": "https://github.com/npm/npm-packlist.git"
   },
   "tap": {
     "test-env": [
       "LC_ALL=sk"
-    ],
-    "check-coverage": true,
-    "nyc-arg": [
-      "--include=index.js",
-      "--include=bin/index.js"
     ]
   },
   "bin": {
     "npm-packlist": "bin/index.js"
   },
   "engines": {
-    "node": ">=10"
+    "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "3.2.2"
   }
 }