Analyzes and walks down the dependencies from a entry of commonjs or es6 module and creates a B+ dependency tree.
$ npm install module-walker --save
const walker = require('module-walker')
let resolve = (nodes) => {
// nodes
}
walker(options)
.on('warn', message => {
console.warn(message)
})
.walk(filename)
.walk(filename)
.then(resolve, reject)
Object.<id>:<walker.Node>
function(nodes)
function(err)
For the example of variable nodes
, see the last section below.
All options are optional. Default options are typically used for node.js environment in strict mode.
Boolean=true
When false, if cyclic dependencies are detected, it will be reject()
ed.Boolean=false
When true, require()
method only accepts one argument. Otherwise, it will be reject()
edBoolean=true
When false, require()
ing an absolute path is not allowed, such as require('/data/a.js')
, which has several issues for browser-side module.Array=['.js', '.json', '.node']
See options.extensions section.Boolean=true
When true, require.resolve()
will be parsed.Boolean=false
Specially, if true, module-walker
will parse the usage of require.async(id)
for some browser-side module loaders.Boolean=true
Whether should check the usage of method require()
. If false, the argument of require()
must be an literal string, otherwise it will be reject()
ed.Boolean=false
When true, it supports to write// @require('./controller/a')
// @require('./controller/b')
const Controller = require(`./controller/${type}`)
which is really helpful for browsers
Boolean=false
By default, import and export declarations can only appear at a program's top level. Setting this option to true allows them anywhere where a statement is allowed. This option is used for babylon
.Boolean=false
By default, a return statement at the top level raises an error. Set this to true to accept such code. This option is used for babylon
.String='module'
Indicate the mode the code should be parsed in. Can be either "script" or "module". This option is used for babylon
.function(code, options)=walker.astFromSource
Method to parse and return the ast(estree) of the given code
. (probably don't use this)function(id, options, callback)=walker.resolve
Asynchronous method to require.resolve()
the given id
. (probably don't use this)type Array
When we require()
a path
, if path
is not found, nodejs will attempt to load the required filename with the added extension of .js
, .json
, and then .node
. Reference via
For browser-side environment, we could use ['.js', '.json']
.
Actually, there is no walker.Node
exists. We only use it to declare and describe the structure of the module.
Property | Type | Description |
---|---|---|
foreign | Boolean |
whether the current module is from a foreign package. |
require | Object |
The <id>: <path> map. id is the module identifier user require() d in the module file. |
resolve | Object |
similar to require
|
async | Object |
similar to async
|
type | Array.<String> |
the type of the current node to be required. see example below. |
If the file structure of your project is (actually it is a very extreme scenario):
/path/to
|-- index.js
|-- a.png
|-- a
|-- index.json
index.js:
require('./a')
require('b')
var image = require.resolve('./a.png')
a/index.json
{}
Code:
walker().walk('/path/to/index.js').then(function(nodes){
console.log(nodes)
});
Then, the nodes
object will be something like:
{
'/path/to/index.js': {
id: '/path/to/index.js',
require: {
'./a': '/path/to/a/index.json',
'b': 'b'
},
resolve: {
'./a.png': '/path/to/a.png'
},
code: <buffer>
type: ['require'] // there is a 'require' type for entry node
},
'/path/to/a.png': {
require: {},
type: ['resolve'] // indicates that this node is `require.resolve()`d
}
'/path/to/a/index.json': {
require: {},
type: ['require'],
code: <buffer>
},
'b': {
foreign: true
}
}
MIT