module-walker

    3.0.2 • Public • Published

    Build Status

    module-walker

    Analyzes and walks down the dependencies from a entry of commonjs or es6 module and creates a B+ dependency tree.

    • Fully implemented File Modules of nodejs.
    • You can define what extensions should commonjs-walker fallback to by options.extensions, which will be very usefull for browser-side modules.

    Install

    $ npm install module-walker --save

    walker(options = {})

    const walker = require('module-walker')
     
    let resolve = (nodes) => {
      // nodes
    }
     
    walker(options)
      .on('warn', message => {
        console.warn(message)
      })
      .walk(filename)
      .walk(filename)
      .then(resolve, reject)
    • nodes Object.<id>:<walker.Node>
    • resolve function(nodes)
    • reject function(err)

    For the example of variable nodes, see the last section below.

    options

    All options are optional. Default options are typically used for node.js environment in strict mode.

    • allowCyclic Boolean=true When false, if cyclic dependencies are detected, it will be reject()ed.
    • checkRequireLength Boolean=false When true, require() method only accepts one argument. Otherwise, it will be reject()ed
    • allowAbsoluteDependency Boolean=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.
    • extensions Array=['.js', '.json', '.node'] See options.extensions section.
    • requireResolve Boolean=true When true, require.resolve() will be parsed.
    • requireAsync Boolean=false Specially, if true, module-walker will parse the usage of require.async(id) for some browser-side module loaders.
    • allowNonLiteralRequire 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.
    • commentRequire 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

    • allowImportExportEverywhere 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.
    • allowReturnOutsideFunction 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.
    • sourceType String='module' Indicate the mode the code should be parsed in. Can be either "script" or "module". This option is used for babylon.
    • parse function(code, options)=walker.astFromSource Method to parse and return the ast(estree) of the given code. (probably don't use this)
    • resolve function(id, options, callback)=walker.resolve Asynchronous method to require.resolve() the given id. (probably don't use this)

    options.extensions

    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'].

    Struct: walker.Node

    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.

    Example

    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
      }
    }

    License

    MIT

    Install

    npm i module-walker

    DownloadsWeekly Downloads

    23

    Version

    3.0.2

    License

    MIT

    Last publish

    Collaborators

    • kael