step-node-agent 3.17.0 → 3.18.1

package/node_modules/resolve/readme.markdown

@@ -1,18 +1,22 @@
-# resolve
+# resolve <sup>[![Version Badge][2]][1]</sup>
 
-implements the [node `require.resolve()`
-algorithm](https://nodejs.org/api/modules.html#modules_all_together)
-such that you can `require.resolve()` on behalf of a file asynchronously and
-synchronously
+implements the [node `require.resolve()` algorithm](https://nodejs.org/api/modules.html#modules_all_together) such that you can `require.resolve()` on behalf of a file asynchronously and synchronously
 
-[![build status](https://secure.travis-ci.org/browserify/resolve.png)](http://travis-ci.org/browserify/resolve)
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![dependency status][5]][6]
+[![dev dependency status][7]][8]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][11]][1]
 
 # example
 
 asynchronously resolve:
 
 ```js
-var resolve = require('resolve');
+var resolve = require('resolve/async'); // or, require('resolve')
 resolve('tap', { basedir: __dirname }, function (err, res) {
     if (err) console.error(err);
     else console.log(res);
@@ -27,8 +31,8 @@ $ node example/async.js
 synchronously resolve:
 
 ```js
-var resolve = require('resolve');
-var res = resolve.sync('tap', { basedir: __dirname });
+var resolve = require('resolve/sync'); // or, `require('resolve').sync
+var res = resolve('tap', { basedir: __dirname });
 console.log(res);
 ```
 
@@ -41,6 +45,8 @@ $ node example/sync.js
 
 ```js
 var resolve = require('resolve');
+var async = require('resolve/async');
+var sync = require('resolve/sync');
 ```
 
 For both the synchronous and asynchronous methods, errors may have any of the following `err.code` values:
@@ -67,7 +73,7 @@ options are:
 
 * opts.isFile - function to asynchronously test whether a file exists
 
-* opts.isDirectory - function to asynchronously test whether a directory exists
+* opts.isDirectory - function to asynchronously test whether a file exists and is a directory
 
 * opts.realpath - function to asynchronously resolve a potential symlink to its real path
 
@@ -79,7 +85,7 @@ options are:
 * `opts.packageFilter(pkg, pkgfile, dir)` - transform the parsed package.json contents before looking at the "main" field
   * pkg - package data
   * pkgfile - path to package.json
-  * dir - directory for package.json
+  * dir - directory that contains package.json
 
 * `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
   * pkg - package data
@@ -177,7 +183,7 @@ options are:
 
 * opts.isFile - function to synchronously test whether a file exists
 
-* opts.isDirectory - function to synchronously test whether a directory exists
+* opts.isDirectory - function to synchronously test whether a file exists and is a directory
 
 * opts.realpathSync - function to synchronously resolve a potential symlink to its real path
 
@@ -187,7 +193,7 @@ options are:
 
 * `opts.packageFilter(pkg, dir)` - transform the parsed package.json contents before looking at the "main" field
   * pkg - package data
-  * dir - directory for package.json (Note: the second argument will change to "pkgfile" in v2)
+  * dir - directory that contains package.json (Note: the second argument will change to "pkgfile" in v2)
 
 * `opts.pathFilter(pkg, path, relativePath)` - transform a path within a package
   * pkg - package data
@@ -277,3 +283,19 @@ npm install resolve
 # license
 
 MIT
+
+[1]: https://npmjs.org/package/resolve
+[2]: https://versionbadg.es/browserify/resolve.svg
+[5]: https://david-dm.org/browserify/resolve.svg
+[6]: https://david-dm.org/browserify/resolve
+[7]: https://david-dm.org/browserify/resolve/dev-status.svg
+[8]: https://david-dm.org/browserify/resolve#info=devDependencies
+[11]: https://nodei.co/npm/resolve.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/resolve.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/resolve.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=resolve
+[codecov-image]: https://codecov.io/gh/browserify/resolve/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/browserify/resolve/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/browserify/resolve
+[actions-url]: https://github.com/browserify/resolve/actions

package/node_modules/resolve/sync.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/sync');

package/node_modules/resolve/test/home_paths.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../async');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazPkg = { name: 'baz', main: 'quux.js' };
+        var dotMainPkg = { main: 'index' };
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            var dotSlashMainPkg = { main: 'index' };
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_main`');
+                        s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                        s2t.deepEqual(pkg, dotMainPkg);
+                    });
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('dot_slash_main', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `dot_slash_main`');
+                        s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                        s2t.deepEqual(pkg, dotSlashMainPkg);
+                    });
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(3);
+
+                    resolve('baz', function (err, res, pkg) {
+                        s2t.error(err, 'no error resolving `baz`');
+                        s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                        s2t.deepEqual(pkg, bazPkg);
+                    });
+                });
+            });
+        });
+    });
+});

package/node_modules/resolve/test/home_paths_sync.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var fs = require('fs');
+var homedir = require('../lib/homedir');
+var path = require('path');
+
+var test = require('tape');
+var mkdirp = require('mkdirp');
+var rimraf = require('rimraf');
+var mv = require('mv');
+var copyDir = require('copy-dir');
+var tmp = require('tmp');
+
+var HOME = homedir();
+
+var hnm = path.join(HOME, '.node_modules');
+var hnl = path.join(HOME, '.node_libraries');
+
+var resolve = require('../sync');
+
+function makeDir(t, dir, cb) {
+    mkdirp(dir, function (err) {
+        if (err) {
+            cb(err);
+        } else {
+            t.teardown(function cleanup() {
+                rimraf.sync(dir);
+            });
+            cb();
+        }
+    });
+}
+
+function makeTempDir(t, dir, cb) {
+    if (fs.existsSync(dir)) {
+        var tmpResult = tmp.dirSync();
+        t.teardown(tmpResult.removeCallback);
+        var backup = path.join(tmpResult.name, path.basename(dir));
+        mv(dir, backup, function (err) {
+            if (err) {
+                cb(err);
+            } else {
+                t.teardown(function () {
+                    mv(backup, dir, cb);
+                });
+                makeDir(t, dir, cb);
+            }
+        });
+    } else {
+        makeDir(t, dir, cb);
+    }
+}
+
+test('homedir module paths', function (t) {
+    t.plan(7);
+
+    makeTempDir(t, hnm, function (err) {
+        t.error(err, 'no error with HNM temp dir');
+        if (err) {
+            return t.end();
+        }
+
+        var bazHNMDir = path.join(hnm, 'baz');
+        var dotMainDir = path.join(hnm, 'dot_main');
+        copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNMDir);
+        copyDir.sync(path.join(__dirname, 'resolver/dot_main'), dotMainDir);
+
+        var bazHNMmain = path.join(bazHNMDir, 'quux.js');
+        t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+        var dotMainMain = path.join(dotMainDir, 'index.js');
+        t.equal(require.resolve('dot_main'), dotMainMain, 'sanity check: require.resolve finds `dot_main`');
+
+        makeTempDir(t, hnl, function (err) {
+            t.error(err, 'no error with HNL temp dir');
+            if (err) {
+                return t.end();
+            }
+            var bazHNLDir = path.join(hnl, 'baz');
+            copyDir.sync(path.join(__dirname, 'resolver/baz'), bazHNLDir);
+
+            var dotSlashMainDir = path.join(hnl, 'dot_slash_main');
+            var dotSlashMainMain = path.join(dotSlashMainDir, 'index.js');
+            copyDir.sync(path.join(__dirname, 'resolver/dot_slash_main'), dotSlashMainDir);
+
+            t.equal(require.resolve('baz'), bazHNMmain, 'sanity check: require.resolve finds HNM `baz`');
+            t.equal(require.resolve('dot_slash_main'), dotSlashMainMain, 'sanity check: require.resolve finds HNL `dot_slash_main`');
+
+            t.test('with temp dirs', function (st) {
+                st.plan(3);
+
+                st.test('just in `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_main');
+                    s2t.equal(res, dotMainMain, '`dot_main` resolves in `$HOME/.node_modules`');
+                });
+
+                st.test('just in `$HOME/.node_libraries`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('dot_slash_main');
+                    s2t.equal(res, dotSlashMainMain, '`dot_slash_main` resolves in `$HOME/.node_libraries`');
+                });
+
+                st.test('in `$HOME/.node_libraries` and `$HOME/.node_modules`', function (s2t) {
+                    s2t.plan(1);
+
+                    var res = resolve('baz');
+                    s2t.equal(res, bazHNMmain, '`baz` resolves in `$HOME/.node_modules` when in both');
+                });
+            });
+        });
+    });
+});

package/node_modules/resolve/test/mock_sync.js

@@ -122,9 +122,8 @@ test('symlinked', function (t) {
                     var dir = path.dirname(resolved);
                     var base = path.basename(resolved);
                     return path.join(dir, 'symlinked', base);
-                } else {
-                    return path.join(resolved, 'symlinked');
                 }
+                return path.join(resolved, 'symlinked');
             }
         };
     }
@@ -183,9 +182,8 @@ test('readPackageSync', function (t) {
     var readPackageSync = function (readFileSync, file) {
         if (file.indexOf(path.join('bar', 'package.json')) >= 0) {
             return { main: './something-else.js' };
-        } else {
-            return JSON.parse(files[path.resolve(file)]);
         }
+        return JSON.parse(files[path.resolve(file)]);
     };
 
     t.test('with readPackage', function (st) {

package/node_modules/resolve/test/node_path.js

@@ -63,7 +63,7 @@ test('$NODE_PATH', function (t) {
         basedir: path.join(__dirname, 'node_path/x'),
         isDirectory: isDir
     }, function (err, res) {
-        var root = require('tap/package.json').main;
+        var root = require('tap/package.json').main; // eslint-disable-line global-require
         t.error(err);
         t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');
     });

package/node_modules/resolve/test/resolver/invalid_main/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "invalid main",
+  "name": "invalid_main",
   "main": [
     "why is this a thing",
     "srsly omg wtf"

package/node_modules/resolve/test/resolver/malformed_package_json/package.json

@@ -0,0 +1 @@
+{

package/node_modules/resolve/test/resolver.js

@@ -1,6 +1,12 @@
 var path = require('path');
 var test = require('tape');
 var resolve = require('../');
+var async = require('../async');
+
+test('`./async` entry point', function (t) {
+    t.equal(resolve, async, '`./async` entry point is the same as `main`');
+    t.end();
+});
 
 test('async foo', function (t) {
     t.plan(12);
@@ -288,7 +294,7 @@ test('without basedir', function (t) {
     t.plan(1);
 
     var dir = path.join(__dirname, 'resolver/without_basedir');
-    var tester = require(path.join(dir, 'main.js'));
+    var tester = require(path.join(dir, 'main.js')); // eslint-disable-line global-require
 
     tester(t, function (err, res, pkg) {
         if (err) {
@@ -404,7 +410,7 @@ test('non-string "main" field in package.json', function (t) {
     var dir = path.join(__dirname, 'resolver');
     resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
         t.ok(err, 'errors on non-string main');
-        t.equal(err.message, 'package “invalid main” `main` must be a string');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
         t.equal(err.code, 'INVALID_PACKAGE_MAIN');
         t.equal(res, undefined, 'res is undefined');
         t.equal(pkg, undefined, 'pkg is undefined');
@@ -417,7 +423,7 @@ test('non-string "main" field in package.json', function (t) {
     var dir = path.join(__dirname, 'resolver');
     resolve('./invalid_main', { basedir: dir }, function (err, res, pkg) {
         t.ok(err, 'errors on non-string main');
-        t.equal(err.message, 'package “invalid main” `main` must be a string');
+        t.equal(err.message, 'package “invalid_main” `main` must be a string');
         t.equal(err.code, 'INVALID_PACKAGE_MAIN');
         t.equal(res, undefined, 'res is undefined');
         t.equal(pkg, undefined, 'pkg is undefined');
@@ -448,3 +454,93 @@ test('browser field in package.json', function (t) {
         }
     );
 });
+
+test('absolute paths', function (t) {
+    t.plan(4);
+
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    resolve(__filename, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file resolves'
+        );
+    });
+    resolve(extensionless, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file resolves'
+        );
+    });
+    resolve(__filename, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'absolute path to this file with a basedir resolves'
+        );
+    });
+    resolve(extensionless, { basedir: process.cwd() }, function (err, res) {
+        t.equal(
+            res,
+            __filename,
+            'extensionless absolute path to this file with a basedir resolves'
+        );
+    });
+});
+
+test('malformed package.json', function (t) {
+    /* eslint operator-linebreak: ["error", "before"], function-paren-newline: "off" */
+    t.plan(
+        (3 * 3) // 3 sets of 3 assertions in the final callback
+        + 2 // 1 readPackage call with malformed package.json
+    );
+
+    var basedir = path.join(__dirname, 'resolver/malformed_package_json');
+    var expected = path.join(basedir, 'index.js');
+
+    resolve('./index.js', { basedir: basedir }, function (err, res, pkg) {
+        t.error(err, 'no error');
+        t.equal(res, expected, 'malformed package.json is silently ignored');
+        t.equal(pkg, undefined, 'malformed package.json gives an undefined `pkg` argument');
+    });
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with packageFilter: no error');
+            t.equal(res, expected, 'with packageFilter: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with packageFilter: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+
+    resolve(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackage: function (readFile, pkgfile, cb) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                readFile(pkgfile, function (err, result) {
+                    try {
+                        cb(null, JSON.parse(result));
+                    } catch (e) {
+                        t.ok(e instanceof SyntaxError, 'readPackage: malformed package.json parses as a syntax error');
+                        cb(null);
+                    }
+                });
+            }
+        },
+        function (err, res, pkg) {
+            t.error(err, 'with readPackage: no error');
+            t.equal(res, expected, 'with readPackage: malformed package.json is silently ignored');
+            t.equal(pkg, undefined, 'with readPackage: malformed package.json gives an undefined `pkg` argument');
+        }
+    );
+});