• Stars
    star
    774
  • Rank 58,703 (Top 2 %)
  • Language
    JavaScript
  • License
    MIT License
  • Created over 13 years ago
  • Updated 6 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Implements the node.js require.resolve() algorithm

resolve Version Badge

implements the node require.resolve() algorithm such that you can require.resolve() on behalf of a file asynchronously and synchronously

github actions coverage dependency status dev dependency status License Downloads

npm badge

example

asynchronously 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);
});
$ node example/async.js
/home/substack/projects/node-resolve/node_modules/tap/lib/main.js

synchronously resolve:

var resolve = require('resolve/sync'); // or, `require('resolve').sync
var res = resolve('tap', { basedir: __dirname });
console.log(res);
$ node example/sync.js
/home/substack/projects/node-resolve/node_modules/tap/lib/main.js

methods

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:

  • MODULE_NOT_FOUND: the given path string (id) could not be resolved to a module
  • INVALID_BASEDIR: the specified opts.basedir doesn't exist, or is not a directory
  • INVALID_PACKAGE_MAIN: a package.json was encountered with an invalid main property (eg. not a string)

resolve(id, opts={}, cb)

Asynchronously resolve the module path string id into cb(err, res [, pkg]), where pkg (if defined) is the data from package.json.

options are:

  • opts.basedir - directory to begin resolving from

  • opts.package - package.json data applicable to the module being loaded

  • opts.extensions - array of file extensions to search in order

  • opts.includeCoreModules - set to false to exclude node core modules (e.g. fs) from the search

  • opts.readFile - how to read files asynchronously

  • opts.isFile - function to asynchronously test whether a file 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

  • opts.readPackage(readFile, pkgfile, cb) - function to asynchronously read and parse a package.json file

    • readFile - the passed opts.readFile or fs.readFile if not specified
    • pkgfile - path to package.json
    • cb - callback. a SyntaxError error argument will be ignored, all other error arguments will be treated as an error.
  • 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 that contains package.json
  • opts.pathFilter(pkg, path, relativePath) - transform a path within a package

    • pkg - package data
    • path - the path being resolved
    • relativePath - the path relative from the package.json location
    • returns - a relative path that will be joined from the package.json location
  • opts.paths - require.paths array to use if nothing is found on the normal node_modules recursive walk (probably don't use this)

    For advanced users, paths can also be a opts.paths(request, start, opts) function

    • request - the import specifier being resolved
    • start - lookup path
    • getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard node_modules resolution
    • opts - the resolution options
  • opts.packageIterator(request, start, opts) - return the list of candidate paths where the packages sources may be found (probably don't use this)

    • request - the import specifier being resolved
    • start - lookup path
    • getPackageCandidates - a thunk (no-argument function) that returns the paths using standard node_modules resolution
    • opts - the resolution options
  • opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: "node_modules"

  • opts.preserveSymlinks - if true, doesn't resolve basedir to real path before resolving. This is the way Node resolves dependencies when executed with the --preserve-symlinks flag.

default opts values:

{
    paths: [],
    basedir: __dirname,
    extensions: ['.js'],
    includeCoreModules: true,
    readFile: fs.readFile,
    isFile: function isFile(file, cb) {
        fs.stat(file, function (err, stat) {
            if (!err) {
                return cb(null, stat.isFile() || stat.isFIFO());
            }
            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
            return cb(err);
        });
    },
    isDirectory: function isDirectory(dir, cb) {
        fs.stat(dir, function (err, stat) {
            if (!err) {
                return cb(null, stat.isDirectory());
            }
            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
            return cb(err);
        });
    },
    realpath: function realpath(file, cb) {
        var realpath = typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
        realpath(file, function (realPathErr, realPath) {
            if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);
            else cb(null, realPathErr ? file : realPath);
        });
    },
    readPackage: function defaultReadPackage(readFile, pkgfile, cb) {
        readFile(pkgfile, function (readFileErr, body) {
            if (readFileErr) cb(readFileErr);
            else {
                try {
                    var pkg = JSON.parse(body);
                    cb(null, pkg);
                } catch (jsonErr) {
                    cb(jsonErr);
                }
            }
        });
    },
    moduleDirectory: 'node_modules',
    preserveSymlinks: false
}

resolve.sync(id, opts)

Synchronously resolve the module path string id, returning the result and throwing an error when id can't be resolved.

options are:

  • opts.basedir - directory to begin resolving from

  • opts.extensions - array of file extensions to search in order

  • opts.includeCoreModules - set to false to exclude node core modules (e.g. fs) from the search

  • opts.readFileSync - how to read files synchronously

  • opts.isFile - function to synchronously test whether a file 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

  • opts.readPackageSync(readFileSync, pkgfile) - function to synchronously read and parse a package.json file. a thrown SyntaxError will be ignored, all other exceptions will propagate.

    • readFileSync - the passed opts.readFileSync or fs.readFileSync if not specified
    • pkgfile - path to package.json
  • 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 that contains package.json
  • opts.pathFilter(pkg, path, relativePath) - transform a path within a package

    • pkg - package data
    • path - the path being resolved
    • relativePath - the path relative from the package.json location
    • returns - a relative path that will be joined from the package.json location
  • opts.paths - require.paths array to use if nothing is found on the normal node_modules recursive walk (probably don't use this)

    For advanced users, paths can also be a opts.paths(request, start, opts) function

    • request - the import specifier being resolved
    • start - lookup path
    • getNodeModulesDirs - a thunk (no-argument function) that returns the paths using standard node_modules resolution
    • opts - the resolution options
  • opts.packageIterator(request, start, opts) - return the list of candidate paths where the packages sources may be found (probably don't use this)

    • request - the import specifier being resolved
    • start - lookup path
    • getPackageCandidates - a thunk (no-argument function) that returns the paths using standard node_modules resolution
    • opts - the resolution options
  • opts.moduleDirectory - directory (or directories) in which to recursively look for modules. default: "node_modules"

  • opts.preserveSymlinks - if true, doesn't resolve basedir to real path before resolving. This is the way Node resolves dependencies when executed with the --preserve-symlinks flag.

default opts values:

{
    paths: [],
    basedir: __dirname,
    extensions: ['.js'],
    includeCoreModules: true,
    readFileSync: fs.readFileSync,
    isFile: function isFile(file) {
        try {
            var stat = fs.statSync(file);
        } catch (e) {
            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
            throw e;
        }
        return stat.isFile() || stat.isFIFO();
    },
    isDirectory: function isDirectory(dir) {
        try {
            var stat = fs.statSync(dir);
        } catch (e) {
            if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
            throw e;
        }
        return stat.isDirectory();
    },
    realpathSync: function realpathSync(file) {
        try {
            var realpath = typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
            return realpath(file);
        } catch (realPathErr) {
            if (realPathErr.code !== 'ENOENT') {
                throw realPathErr;
            }
        }
        return file;
    },
    readPackageSync: function defaultReadPackageSync(readFileSync, pkgfile) {
        return JSON.parse(readFileSync(pkgfile));
    },
    moduleDirectory: 'node_modules',
    preserveSymlinks: false
}

install

With npm do:

npm install resolve

license

MIT

More Repositories

1

browserify

browser-side require() the node.js way
JavaScript
14,579
star
2

browserify-handbook

how to build modular applications with browserify
JavaScript
4,584
star
3

watchify

watch mode for browserify builds
JavaScript
1,788
star
4

events

Node's event emitter for all engines.
JavaScript
1,370
star
5

crypto-browserify

partial implementation of node's `crypto` for the browser
JavaScript
652
star
6

wzrd.in

browserify as a service.
JavaScript
636
star
7

browserify-website

the code that runs http://browserify.org
HTML
588
star
8

brfs

browserify fs.readFileSync() static asset inliner
JavaScript
563
star
9

rustify

Rust WebAssembly transform for Browserify
JavaScript
494
star
10

webworkify

launch a web worker that can require() in the browser with browserify
JavaScript
416
star
11

detective

Find all calls to require() no matter how deeply nested using a proper walk of the AST
JavaScript
414
star
12

tinyify

a browserify plugin that runs various optimizations, so you don't have to install them all manually. makes your bundles tiny!
JavaScript
411
star
13

factor-bundle

factor browser-pack bundles into common shared bundles
JavaScript
402
star
14

commonjs-assert

Node.js's require('assert') for all engines
JavaScript
293
star
15

sha.js

Streamable SHA hashes in pure javascript
JavaScript
287
star
16

http-browserify

node's http module, but for the browser
JavaScript
244
star
17

node-util

node.js util module as a module
JavaScript
244
star
18

module-deps

walk the dependency graph to generate a stream of json output
JavaScript
209
star
19

vm-browserify

require('vm') like in node but for the browser
JavaScript
200
star
20

bundle-collapser

convert bundle paths to IDs to save bytes in browserify bundles
JavaScript
195
star
21

pbkdf2

PBKDF2 with any supported hashing algorithm in Node
JavaScript
189
star
22

browser-pack

pack node-style source files from a json stream into a browser bundle
JavaScript
174
star
23

static-eval

evaluate statically-analyzable expressions
JavaScript
171
star
24

path-browserify

The path module from Node.js for browsers
JavaScript
168
star
25

common-shakeify

browserify tree shaking plugin using `common-shake`
JavaScript
105
star
26

stream-browserify

the stream module from node core for browsers
JavaScript
101
star
27

browser-resolve

resolve function which support the browser field in package.json
JavaScript
101
star
28

randombytes

random bytes from browserify stand alone
JavaScript
99
star
29

diffie-hellman

pure js diffie-hellman
JavaScript
94
star
30

awesome-browserify

🔮 A curated list of awesome Browserify resources, libraries, and tools.
88
star
31

syntax-error

detect and report syntax errors in source code strings
JavaScript
79
star
32

static-module

convert module usage to inline expressions
JavaScript
74
star
33

ify-loader

Webpack loader to handle browserify transforms as intended.
JavaScript
68
star
34

browserify-aes

aes, for browserify
JavaScript
62
star
35

createHmac

Node style HMAC for use in the browser, with native implementation in node
JavaScript
62
star
36

browserify-zlib

Full zlib module for browserify
JavaScript
57
star
37

browser-unpack

parse a bundle generated by browser-pack
JavaScript
55
star
38

stream-splicer

streaming pipeline with a mutable configuration
JavaScript
55
star
39

createHash

Node style hashes for use in the browser, with native hash functions in node
JavaScript
52
star
40

md5.js

node style md5 on pure JavaScript
JavaScript
44
star
41

browserify-sign

createSign and createVerify in your browser
JavaScript
43
star
42

labeled-stream-splicer

stream splicer with labels
JavaScript
42
star
43

console-browserify

Emulate console for all the browsers
JavaScript
33
star
44

ripemd160

JavaScript component to compute the RIPEMD160 hash of strings or bytes.
JavaScript
32
star
45

buffer-xor

A simple module for bitwise-xor on buffers
JavaScript
30
star
46

publicEncrypt

publicEncrypt/privateDecrypt for browserify
JavaScript
29
star
47

insert-module-globals

insert implicit module globals into a module-deps stream
JavaScript
26
star
48

createECDH

browserify version of crypto.createECDH
JavaScript
24
star
49

timers-browserify

timers module for browserify
JavaScript
24
star
50

parse-asn1

JavaScript
21
star
51

EVP_BytesToKey

JavaScript
20
star
52

browserify-rsa

JavaScript
19
star
53

cipher-base

abstract base class for crypto-streams
JavaScript
18
star
54

browserify-cipher

JavaScript
18
star
55

tty-browserify

the tty module from node core for browsers
JavaScript
17
star
56

deps-sort

sort module-deps output for deterministic browserify bundles
JavaScript
16
star
57

acorn-node

the acorn javascript parser, preloaded with plugins for syntax parity with recent node versions
JavaScript
13
star
58

admin

administrative procedures for the browserify org
12
star
59

hash-base

abstract base class for hash-streams
JavaScript
11
star
60

discuss

discuss project organization, initiatives, and whatever!
11
star
61

browserify-des

DES for browserify
JavaScript
10
star
62

randomfill

JavaScript
9
star
63

buffer-reverse

A lite module for byte reversal on buffers.
JavaScript
6
star
64

detective-esm

find es module dependencies [experimental]
JavaScript
3
star
65

hash-test-vectors

JavaScript
3
star
66

pseudorandombytes

pseudorandombytes for the browser
JavaScript
3
star
67

perf-hooks-browserify

[WIP] The perf_hooks node module API for browserify
JavaScript
3
star
68

.github

Housing of Browserify's GitHub configuration and base files
2
star
69

timing-safe-equal

JavaScript
1
star
70

scrypt

JavaScript
1
star