resolve - npm Package Compare versions

Comparing version 2.0.0-next.3 to 2.0.0-next.4

lib/async.js

 var fs = require('fs');
+var getHomedir = require('./homedir');
 var path = require('path');
@@ -8,4 +9,12 @@ var caller = require('./caller');
 
-var realpathFS = fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
 
+var homedir = getHomedir();
+var defaultPaths = function () {
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+};
+
 var defaultIsFile = function isFile(file, cb) {
@@ -54,3 +63,3 @@ fs.stat(file, function (err, stat) {
             } catch (jsonErr) {
-                cb(null);
+                cb(jsonErr);
             }
@@ -103,3 +112,3 @@ }
 
-    opts.paths = opts.paths || [];
+    opts.paths = opts.paths || defaultPaths();
 
@@ -239,3 +248,3 @@ // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
                 readPackage(readFile, pkgfile, function (err, pkgParam) {
-                    if (err) cb(err);
+                    if (err && !(err instanceof SyntaxError)) cb(err);
 
@@ -242,0 +251,0 @@ var pkg = pkgParam;

lib/node-modules-paths.js

 var path = require('path');
-var parse = path.parse || require('path-parse');
+var parse = path.parse || require('path-parse'); // eslint-disable-line global-require
 
@@ -4,0 +4,0 @@ var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {

lib/sync.js

 var isCore = require('is-core-module');
 var fs = require('fs');
 var path = require('path');
+var getHomedir = require('./homedir');
 var caller = require('./caller');
@@ -8,7 +9,15 @@ var nodeModulesPaths = require('./node-modules-paths');
 
-var realpathFS = fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
 
+var homedir = getHomedir();
+var defaultPaths = function () {
+    return [
+        path.join(homedir, '.node_modules'),
+        path.join(homedir, '.node_libraries')
+    ];
+};
+
 var defaultIsFile = function isFile(file) {
     try {
-        var stat = fs.statSync(file);
+        var stat = fs.statSync(file, { throwIfNoEntry: false });
     } catch (e) {
@@ -18,3 +27,3 @@ if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
     }
-    return stat.isFile() || stat.isFIFO();
+    return !!stat && (stat.isFile() || stat.isFIFO());
 };
@@ -24,3 +33,3 @@
     try {
-        var stat = fs.statSync(dir);
+        var stat = fs.statSync(dir, { throwIfNoEntry: false });
     } catch (e) {
@@ -30,3 +39,3 @@ if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
     }
-    return stat.isDirectory();
+    return !!stat && stat.isDirectory();
 };
@@ -53,7 +62,3 @@
 var defaultReadPackageSync = function defaultReadPackageSync(readFileSync, pkgfile) {
-    var body = readFileSync(pkgfile);
-    try {
-        var pkg = JSON.parse(body);
-        return pkg;
-    } catch (jsonErr) {}
+    return JSON.parse(readFileSync(pkgfile));
 };
@@ -90,3 +95,3 @@
 
-    opts.paths = opts.paths || [];
+    opts.paths = opts.paths || defaultPaths();
 
@@ -154,3 +159,10 @@ // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
 
-        var pkg = readPackageSync(readFileSync, pkgfile);
+        var pkg;
+        try {
+            pkg = readPackageSync(readFileSync, pkgfile);
+        } catch (e) {
+            if (!(e instanceof SyntaxError)) {
+                throw e;
+            }
+        }
 
@@ -157,0 +169,0 @@ if (pkg && opts.packageFilter) {

package.json

 {
 	"name": "resolve",
 	"description": "resolve like require.resolve() on behalf of files asynchronously and synchronously",
-	"version": "2.0.0-next.3",
+	"version": "2.0.0-next.4",
 	"repository": {
@@ -9,2 +9,5 @@ "type": "git",
 	},
+	"bin": {
+		"resolve": "./bin/resolve"
+	},
 	"main": "index.js",
@@ -19,14 +22,5 @@ "exports": {
 		],
-		"./sync": [
-			{
-				"default": "./lib/sync.js"
-			},
-			"./lib/sync.js"
-		],
-		"./async": [
-			{
-				"default": "./lib/async.js"
-			},
-			"./lib/async.js"
-		]
+		"./sync": "./lib/sync.js",
+		"./async": "./lib/async.js",
+		"./package.json": "./package.json"
 	},
@@ -40,5 +34,7 @@ "keywords": [
 	"scripts": {
-		"prepublish": "safe-publish-latest",
-		"prelint": "eclint check '**/*'",
-		"lint": "eslint --ext=js,mjs .",
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')",
+		"lint": "eslint --ext=js,mjs --no-eslintrc -c .eslintrc . 'bin/**'",
 		"pretests-only": "cd ./test/resolver/nested_symlinks && node mylib/sync && node mylib/async",
@@ -52,11 +48,18 @@ "tests-only": "tape test/*.js",
 	"devDependencies": {
-		"@ljharb/eslint-config": "^17.5.1",
-		"array.prototype.map": "^1.0.3",
-		"aud": "^1.1.4",
+		"@ljharb/eslint-config": "^21.0.0",
+		"array.prototype.map": "^1.0.4",
+		"aud": "^2.0.0",
+		"copy-dir": "^1.3.0",
 		"eclint": "^2.8.1",
-		"eslint": "^7.19.0",
+		"eslint": "=8.8.0",
+		"in-publish": "^2.0.1",
+		"mkdirp": "^0.5.5",
+		"mv": "^2.1.1",
+		"npmignore": "^0.3.0",
 		"object-keys": "^1.1.1",
-		"safe-publish-latest": "^1.1.4",
+		"rimraf": "^2.7.1",
+		"safe-publish-latest": "^2.0.0",
 		"tap": "0.4.13",
-		"tape": "^5.1.1"
+		"tape": "^5.5.3",
+		"tmp": "^0.0.31"
 	},
@@ -73,5 +76,12 @@ "license": "MIT",
 	"dependencies": {
-		"is-core-module": "^2.2.0",
-		"path-parse": "^1.0.6"
+		"is-core-module": "^2.9.0",
+		"path-parse": "^1.0.7",
+		"supports-preserve-symlinks-flag": "^1.0.0"
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows",
+			"appveyor.yml"
+		]
 	}
 }

test/mock_sync.js

@@ -126,5 +126,4 @@ var path = require('path');
                     return path.join(dir, 'symlinked', base);
-                } else {
-                    return path.join(resolved, 'symlinked');
                 }
+                return path.join(resolved, 'symlinked');
             }
@@ -188,5 +187,4 @@ };
             return { main: './something-else.js' };
-        } else {
-            return JSON.parse(files[path.resolve(file)]);
         }
+        return JSON.parse(files[path.resolve(file)]);
     };
@@ -193,0 +191,0 @@

test/node_path.js

@@ -66,3 +66,3 @@ var fs = require('fs');
     }, 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);
@@ -69,0 +69,0 @@ t.equal(res, path.resolve(__dirname, '..', 'node_modules/tap', root), 'tap resolves');

test/resolver_sync.js

 var path = require('path');
+var fs = require('fs');
 var test = require('tape');
+
 var resolve = require('../');
+var sync = require('../sync');
 
+var requireResolveSupportsPaths = require.resolve.length > 1
+    && !(/^v12\.[012]\./).test(process.version); // broken in v12.0-12.2, see https://github.com/nodejs/node/issues/27794
+
+test('`./sync` entry point', function (t) {
+    t.equal(resolve.sync, sync, '`./sync` entry point is the same as `.sync` on `main`');
+    t.end();
+});
+
 test('foo', function (t) {
@@ -10,9 +21,25 @@ var dir = path.join(__dirname, 'resolver');
         resolve.sync('./foo', { basedir: dir }),
-        path.join(dir, 'foo.js')
+        path.join(dir, 'foo.js'),
+        './foo'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: dir }),
+            require.resolve('./foo', { paths: [dir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
 
     t.equal(
         resolve.sync('./foo.js', { basedir: dir }),
-        path.join(dir, 'foo.js')
+        path.join(dir, 'foo.js'),
+        './foo.js'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo.js', { basedir: dir }),
+            require.resolve('./foo.js', { paths: [dir] }),
+            './foo.js: resolve.sync === require.resolve'
+        );
+    }
 
@@ -45,6 +72,17 @@ t.equal(
 
+    var basedir = path.join(dir, 'bar');
+
     t.equal(
-        resolve.sync('foo', { basedir: path.join(dir, 'bar') }),
-        path.join(dir, 'bar/node_modules/foo/index.js')
+        resolve.sync('foo', { basedir: basedir }),
+        path.join(dir, 'bar/node_modules/foo/index.js'),
+        'foo in bar'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('foo', { basedir: basedir }),
+            require.resolve('foo', { paths: [basedir] }),
+            'foo in bar: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -58,4 +96,13 @@ });
         resolve.sync('./baz', { basedir: dir }),
-        path.join(dir, 'baz/quux.js')
+        path.join(dir, 'baz/quux.js'),
+        './baz'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./baz', { basedir: dir }),
+            require.resolve('./baz', { paths: [dir] }),
+            './baz: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -66,2 +113,3 @@ });
     var dir = path.join(__dirname, 'resolver/biz/node_modules');
+
     t.equal(
@@ -71,12 +119,36 @@ resolve.sync('./grux', { basedir: dir }),
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./grux', { basedir: dir }),
+            require.resolve('./grux', { paths: [dir] }),
+            './grux: resolve.sync === require.resolve'
+        );
+    }
 
+    var tivDir = path.join(dir, 'grux');
     t.equal(
-        resolve.sync('tiv', { basedir: path.join(dir, 'grux') }),
+        resolve.sync('tiv', { basedir: tivDir }),
         path.join(dir, 'tiv/index.js')
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('tiv', { basedir: tivDir }),
+            require.resolve('tiv', { paths: [tivDir] }),
+            'tiv: resolve.sync === require.resolve'
+        );
+    }
 
+    var gruxDir = path.join(dir, 'tiv');
     t.equal(
-        resolve.sync('grux', { basedir: path.join(dir, 'tiv') }),
+        resolve.sync('grux', { basedir: gruxDir }),
         path.join(dir, 'grux/index.js')
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('grux', { basedir: gruxDir }),
+            require.resolve('grux', { paths: [gruxDir] }),
+            'grux: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -87,2 +159,3 @@ });
     var dir = path.join(__dirname, 'resolver/biz/node_modules/grux');
+
     t.equal(
@@ -92,2 +165,10 @@ resolve.sync('../grux', { basedir: dir }),
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('../grux', { basedir: dir }),
+            require.resolve('../grux', { paths: [dir] }),
+            '../grux: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -98,2 +179,3 @@ });
     var dir = path.join(__dirname, 'resolver');
+
     t.equal(
@@ -104,3 +186,4 @@ resolve.sync('./cup', {
         }),
-        path.join(dir, 'cup.coffee')
+        path.join(dir, 'cup.coffee'),
+        './cup -> ./cup.coffee'
     );
@@ -110,3 +193,4 @@
         resolve.sync('./cup.coffee', { basedir: dir }),
-        path.join(dir, 'cup.coffee')
+        path.join(dir, 'cup.coffee'),
+        './cup.coffee'
     );
@@ -121,2 +205,10 @@
 
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./cup.coffee', { basedir: dir, extensions: ['.js', '.coffee'] }),
+            require.resolve('./cup.coffee', { paths: [dir] }),
+            './cup.coffee: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -127,6 +219,15 @@ });
     var dir = path.join(__dirname, 'resolver');
+
     t.equal(
         resolve.sync('./mug', { basedir: dir }),
-        path.join(dir, 'mug.js')
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./mug', { basedir: dir }),
+            require.resolve('./mug', { paths: [dir] }),
+            './mug: resolve.sync === require.resolve'
+        );
+    }
 
@@ -138,3 +239,4 @@ t.equal(
         }),
-        path.join(dir, 'mug.coffee')
+        path.join(dir, 'mug.coffee'),
+        './mug -> ./mug.coffee'
     );
@@ -147,3 +249,4 @@
         }),
-        path.join(dir, 'mug.js')
+        path.join(dir, 'mug.js'),
+        './mug -> ./mug.js'
     );
@@ -212,2 +315,9 @@
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./incorrect_main', { basedir: resolverDir }),
+            require.resolve('./incorrect_main', { paths: [resolverDir] }),
+            './incorrect_main: resolve.sync === require.resolve'
+        );
+    }
 
@@ -217,4 +327,80 @@ t.end();
 
+test('missing index', function (t) {
+    t.plan(requireResolveSupportsPaths ? 2 : 1);
+
+    var resolverDir = path.join(__dirname, 'resolver');
+    try {
+        resolve.sync('./missing_index', { basedir: resolverDir });
+        t.fail('did not fail');
+    } catch (err) {
+        t.equal(err && err.code, 'INCORRECT_PACKAGE_MAIN', 'error has correct error code');
+    }
+    if (requireResolveSupportsPaths) {
+        try {
+            require.resolve('./missing_index', { basedir: resolverDir });
+            t.fail('require.resolve did not fail');
+        } catch (err) {
+            t.equal(err && err.code, 'MODULE_NOT_FOUND', 'error has correct error code');
+        }
+    }
+});
+
+test('missing main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'missing_main');
+
+    t.equal(
+        resolve.sync('./missing_main', { basedir: resolverDir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./missing_main', { basedir: resolverDir }),
+            require.resolve('./missing_main', { paths: [resolverDir] }),
+            '"main" missing: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('null main', function (t) {
+    var resolverDir = path.join(__dirname, 'resolver');
+    var dir = path.join(resolverDir, 'null_main');
+
+    t.equal(
+        resolve.sync('./null_main', { basedir: resolverDir }),
+        path.join(dir, 'index.js')
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./null_main', { basedir: resolverDir }),
+            require.resolve('./null_main', { paths: [resolverDir] }),
+            '`"main": null`: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('main: false', function (t) {
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    t.equal(
+        resolve.sync('./false_main', { basedir: basedir }),
+        path.join(dir, 'index.js'),
+        '`"main": false`: resolves to `index.js`'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./false_main', { basedir: basedir }),
+            require.resolve('./false_main', { paths: [basedir] }),
+            '`"main": false`: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
 var stubStatSync = function stubStatSync(fn) {
-    var fs = require('fs');
     var statSync = fs.statSync;
@@ -245,11 +431,28 @@ try {
     var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names');
 
     t.equal(
-        resolve.sync('./foo', { basedir: path.join(dir, 'same_names') }),
+        resolve.sync('./foo', { basedir: basedir }),
         path.join(dir, 'same_names/foo.js')
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo', { basedir: basedir }),
+            require.resolve('./foo', { paths: [basedir] }),
+            './foo: resolve.sync === require.resolve'
+        );
+    }
+
     t.equal(
-        resolve.sync('./foo/', { basedir: path.join(dir, 'same_names') }),
+        resolve.sync('./foo/', { basedir: basedir }),
         path.join(dir, 'same_names/foo/index.js')
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./foo/', { basedir: basedir }),
+            require.resolve('./foo/', { paths: [basedir] }),
+            './foo/: resolve.sync === require.resolve'
+        );
+    }
+
     t.end();
@@ -260,11 +463,31 @@ });
     var dir = path.join(__dirname, 'resolver');
+    var basedir = path.join(dir, 'same_names/foo');
 
     t.equal(
-        resolve.sync('./', { basedir: path.join(dir, 'same_names/foo') }),
-        path.join(dir, 'same_names/foo/index.js')
+        resolve.sync('./', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        './'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./', { basedir: basedir }),
+            require.resolve('./', { paths: [basedir] }),
+            './: resolve.sync === require.resolve'
+        );
+    }
+
     t.equal(
-        resolve.sync('.', { basedir: path.join(dir, 'same_names/foo') }),
-        path.join(dir, 'same_names/foo/index.js')
+        resolve.sync('.', { basedir: basedir }),
+        path.join(dir, 'same_names/foo/index.js'),
+        '.'
     );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('.', { basedir: basedir }),
+            require.resolve('.', { paths: [basedir] }),
+            '.: resolve.sync === require.resolve',
+            { todo: true }
+        );
+    }
+
     t.end();
@@ -282,2 +505,8 @@ });
         );
+        st.equal(
+            resolve.sync('./' + testFile),
+            require.resolve('./' + testFile),
+            'sanity check: resolve.sync === require.resolve'
+        );
+
         st.end();
@@ -310,4 +539,16 @@ });
     var start = new Date();
-    t.equal(resolve.sync('./resolver/dot_main'), path.join(__dirname, 'resolver/dot_main/index.js'));
+
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        path.join(__dirname, 'resolver/dot_main/index.js'),
+        './resolver/dot_main'
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_main'),
+        require.resolve('./resolver/dot_main'),
+        './resolver/dot_main: resolve.sync === require.resolve'
+    );
+
     t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
     t.end();
@@ -318,4 +559,15 @@ });
     var start = new Date();
-    t.equal(resolve.sync('./resolver/dot_slash_main'), path.join(__dirname, 'resolver/dot_slash_main/index.js'));
+
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        path.join(__dirname, 'resolver/dot_slash_main/index.js')
+    );
+    t.equal(
+        resolve.sync('./resolver/dot_slash_main'),
+        require.resolve('./resolver/dot_slash_main'),
+        './resolver/dot_slash_main: resolve.sync === require.resolve'
+    );
+
     t.ok(new Date() - start < 50, 'resolve.sync timedout');
+
     t.end();
@@ -345,3 +597,3 @@ });
         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');
@@ -360,3 +612,3 @@ }
         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');
@@ -382,1 +634,114 @@ }
 });
+
+test('absolute paths', function (t) {
+    var extensionless = __filename.slice(0, -path.extname(__filename).length);
+
+    t.equal(
+        resolve.sync(__filename),
+        __filename,
+        'absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(extensionless),
+        __filename,
+        'extensionless absolute path to this file resolves'
+    );
+    t.equal(
+        resolve.sync(__filename),
+        require.resolve(__filename),
+        'absolute path to this file: resolve.sync === require.resolve'
+    );
+
+    t.equal(
+        resolve.sync(__filename, { basedir: process.cwd() }),
+        __filename,
+        'absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(__filename, { basedir: process.cwd() }),
+            require.resolve(__filename, { paths: [process.cwd()] }),
+            'absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.equal(
+        resolve.sync(extensionless, { basedir: process.cwd() }),
+        __filename,
+        'extensionless absolute path to this file with a basedir resolves'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync(extensionless, { basedir: process.cwd() }),
+            require.resolve(extensionless, { paths: [process.cwd()] }),
+            'extensionless absolute path to this file + basedir: resolve.sync === require.resolve'
+        );
+    }
+
+    t.end();
+});
+
+test('malformed package.json', function (t) {
+    t.plan(5 + (requireResolveSupportsPaths ? 1 : 0));
+
+    var basedir = path.join(__dirname, 'resolver/malformed_package_json');
+    var expected = path.join(basedir, 'index.js');
+
+    t.equal(
+        resolve.sync('./index.js', { basedir: basedir }),
+        expected,
+        'malformed package.json is silently ignored'
+    );
+    if (requireResolveSupportsPaths) {
+        t.equal(
+            resolve.sync('./index.js', { basedir: basedir }),
+            require.resolve('./index.js', { paths: [basedir] }),
+            'malformed package.json: resolve.sync === require.resolve'
+        );
+    }
+
+    var res1 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            packageFilter: function (pkg, pkgfile, dir) {
+                t.fail('should not reach here');
+            }
+        }
+    );
+
+    t.equal(
+        res1,
+        expected,
+        'with packageFilter: malformed package.json is silently ignored'
+    );
+
+    var res2 = resolve.sync(
+        './index.js',
+        {
+            basedir: basedir,
+            readPackageSync: function (readFileSync, pkgfile) {
+                t.equal(pkgfile, path.join(basedir, 'package.json'), 'readPackageSync: `pkgfile` is package.json path');
+                var result = String(readFileSync(pkgfile));
+                try {
+                    return JSON.parse(result);
+                } catch (e) {
+                    t.ok(e instanceof SyntaxError, 'readPackageSync: malformed package.json parses as a syntax error');
+                    throw e;
+                }
+            }
+        }
+    );
+
+    t.equal(
+        res2,
+        expected,
+        'with readPackageSync: malformed package.json is silently ignored'
+    );
+});

test/resolver.js

 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) {
@@ -333,2 +339,21 @@ t.plan(12);
 
+test('main: false', function (t) {
+    t.plan(2);
+
+    var basedir = path.join(__dirname, 'resolver');
+    var dir = path.join(basedir, 'false_main');
+    resolve('./false_main', { basedir: basedir }, function (err, res, pkg) {
+        if (err) t.fail(err);
+        t.equal(
+            res,
+            path.join(dir, 'index.js'),
+            '`"main": false`: resolves to `index.js`'
+        );
+        t.deepEqual(pkg, {
+            name: 'false_main',
+            main: false
+        });
+    });
+});
+
 test('without basedir', function (t) {
@@ -338,3 +363,3 @@ 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
 
@@ -455,3 +480,3 @@ tester(t, 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');
@@ -469,3 +494,3 @@ t.equal(res, undefined, 'res is undefined');
         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');
@@ -501,1 +526,91 @@ t.equal(res, undefined, 'res is undefined');
 });
+
+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(e);
+                    }
+                });
+            }
+        },
+        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');
+        }
+    );
+});

test/resolver/invalid_main/package.json

 {
-  "name": "invalid main",
+  "name": "invalid_main",
   "main": [
@@ -4,0 +4,0 @@ "why is this a thing",

New alerts

Nonpermissive License

License

(Experimental) A package's licensing information has fine-grained problems

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 8 instances in 1 package

Improved metrics

Total package byte prevSize

137507

increased by23.03%

Number of package files

104

increased by8.33%

Lines of code

3073

increased by27.25%

Number of lines in readme file

295

increased by6.5%

Worsened metrics

Dependency count

3

increased by50%

Dev dependency count

16

increased by77.78%

Number of medium license alerts

1

increased byInfinity%

Number of low supply chain risk alerts

21

increased by250%

Dependency changes

• + Addedsupports-preserve-symlinks-flag@^1.0.0

• + Addedsupports-preserve-symlinks-flag@1.0.0(transitive)

• Updatedis-core-module@^2.9.0

• Updatedpath-parse@^1.0.7