npm-packlist 2.1.1 → 2.1.5

package/index.js

@@ -83,13 +83,23 @@ const npmWalker = Class => class Walker extends Class {
     opt.path = opt.path || process.cwd()
     const dirName = path.basename(opt.path)
     const parentName = path.basename(path.dirname(opt.path))
-    opt.follow =
-      dirName === 'node_modules' ||
-      (parentName === 'node_modules' && /^@/.test(dirName))
+
+    // only follow links in the root node_modules folder, because if those
+    // folders are included, it's because they're bundled, and bundles
+    // should include the contents, not the symlinks themselves.
+    // This regexp tests to see that we're either a node_modules folder,
+    // or a @scope within a node_modules folder, in the root's node_modules
+    // 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)
+    opt.follow = followRe.test(followTestPath)
+
     super(opt)
 
     // ignore a bunch of things by default at the root level.
-    // also ignore anything in node_modules, except bundled dependencies
+    // also ignore anything in the main project node_modules hierarchy,
+    // except bundled dependencies
     if (!this.parent) {
       this.bundled = opt.bundled || []
       this.bundledScopes = Array.from(new Set(
@@ -172,6 +182,13 @@ const npmWalker = Class => class Walker extends Class {
 
   getPackageFiles (entries, pkg) {
     try {
+      // XXX this could be changed to use read-package-json-fast
+      // which handles the normalizing of bins for us, and simplifies
+      // the test for bundleDependencies and bundledDependencies later.
+      // HOWEVER if we do this, we need to be sure that we're careful
+      // about what we write back out since rpj-fast removes some fields
+      // that the user likely wants to keep. it also would add a second
+      // file read that we would want to optimize away.
       pkg = normalizePackageBin(JSON.parse(pkg.toString()))
     } catch (er) {
       // not actually a valid package.json
@@ -192,7 +209,7 @@ 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 && 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) => {
@@ -210,35 +227,47 @@ const npmWalker = Class => class Walker extends Class {
     let n = patterns.length
     const set = new Set()
     const negates = new Set()
-    const then = (pattern, negate, er, fileList) => {
+    const results = []
+    const then = (pattern, negate, er, fileList, i) => {
       if (er)
         return this.emit('error', er)
 
-      if (negate) {
-        fileList.forEach(f => {
-          set.delete(f)
-          negates.add(f)
-        })
-      } else {
-        fileList.forEach(f => {
-          set.add(f)
-          negates.delete(f)
-        })
-      }
-
+      results[i] = { negate, fileList }
       if (--n === 0) {
-        const list = Array.from(set)
-        // replace the files array with our computed explicit set
-        pkg.files = list.concat(Array.from(negates).map(f => '!' + f))
-        const rdResult = Array.from(new Set(
-          list.map(f => f.replace(/^\/+/, ''))
-        ))
-        super.onReaddir(rdResult)
+        processResults(results)
       }
     }
+    const processResults = results => {
+      for (const {negate, fileList} of results) {
+        if (negate) {
+          fileList.forEach(f => {
+            f = f.replace(/\/+$/, '')
+            set.delete(f)
+            negates.add(f)
+          })
+        } else {
+          fileList.forEach(f => {
+            f = f.replace(/\/+$/, '')
+            set.add(f)
+            negates.delete(f)
+          })
+        }
+      }
+
+      const list = Array.from(set)
+      // replace the files array with our computed explicit set
+      pkg.files = list.concat(Array.from(negates).map(f => '!' + f))
+      const rdResult = Array.from(new Set(
+        list.map(f => f.replace(/^\/+/, ''))
+      ))
+      super.onReaddir(rdResult)
+    }
 
-    patterns.forEach(({pattern, negate}) =>
-      this.globFiles(pattern, (er, res) => then(pattern, negate, er, res)))
+    // 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) =>
+      this.globFiles(pattern, (er, res) => then(pattern, negate, er, res, i)))
   }
 
   filterEntry (entry, partial) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-packlist",
-  "version": "2.1.1",
+  "version": "2.1.5",
   "description": "Get a list of the files to add from a folder into an npm package",
   "directories": {
     "test": "test"
@@ -20,14 +20,14 @@
   "devDependencies": {
     "mutate-fs": "^2.1.1",
     "require-inject": "^1.4.4",
-    "tap": "^14.10.6"
+    "tap": "^14.10.8"
   },
   "scripts": {
     "test": "tap",
     "snap": "tap",
     "preversion": "npm test",
     "postversion": "npm publish",
-    "postpublish": "git push origin --follow-tags"
+    "prepublishOnly": "git push origin --follow-tags"
   },
   "repository": {
     "type": "git",
@@ -40,7 +40,9 @@
       "--include=bin/index.js"
     ]
   },
-  "bin": "bin/index.js",
+  "bin": {
+    "npm-packlist": "bin/index.js"
+  },
   "engines": {
     "node": ">=10"
   }