node-source-walk

What is node-source-walk?

The node-source-walk package is a tool for traversing the abstract syntax tree (AST) of JavaScript code. It allows developers to analyze and manipulate the source code by providing an easy way to walk through the tree structure generated from the code.

What are node-source-walk's main functionalities?

Walking the AST of JavaScript code

This feature allows you to walk through the AST of a given JavaScript code snippet and perform actions based on the type of node encountered. In the code sample, the function logs a message whenever it encounters a variable declaration.

const walk = require('node-source-walk');

const sourceCode = 'var x = 1; console.log(x);';

walk(sourceCode, function(node) {
  if (node.type === 'VariableDeclaration') {
    console.log('Found a variable declaration!');
  }
});

Support for different parsers

node-source-walk supports various parsers like Esprima, Acorn, and Babel. This allows for flexibility in handling different JavaScript syntaxes, including experimental features and JSX. The code sample demonstrates how to specify a custom parser and its options.

const walk = require('node-source-walk');
const babelParser = require('@babel/parser');

const sourceCode = 'let x = 1;';

walk(sourceCode, {
  parser: babelParser,
  parserOptions: {
    sourceType: 'module',
    plugins: ['jsx']
  }
}, function(node) {
  // Analyze the node
});

Other packages similar to node-source-walk

estraverse

Estraverse is a simple and flexible library for traversing and manipulating the AST of ECMAScript 5.1. It is similar to node-source-walk but focuses on ECMAScript 5.1 and does not have built-in support for JSX or experimental JavaScript features.

acorn-walk

Acorn-walk is a tiny, fast JavaScript parser, built on Acorn. It provides a simple interface for walking the AST and is similar to node-source-walk but is tightly coupled with the Acorn parser.

babel-traverse

Babel-traverse is part of the Babel toolchain and provides the ability to traverse and update the AST. It is more powerful and complex than node-source-walk, with a focus on transforming code to work with Babel's plugin system.

README

Execute a callback on every node of a source code's AST and stop walking whenever you see fit.

A variation of substack/node-detective and simplification of substack/node-falafel.

npm install node-source-walk

Usage

  var Walker = require('node-source-walk');

  var walker = new Walker();

  // Assume src is the string contents of myfile.js

  walker.walk(src, function (node) {
    // Example: looking for the use of define()
    var callee = node.callee;

    if (callee &&
        node.type === 'CallExpression' &&
        callee.type === 'Identifier' &&
        callee.name === 'define') {
          console.log('AMD syntax');

          // No need to keep traversing since we found
          // what we wanted
          walker.stopWalking();
        }
  });

By default, Walker will use esprima, but you can switch to esprima-fb (harmony branch) as follows:

var walker = new Walker({
  esprimaHarmony: true
});

Public Members

walk(src, cb)

• Generates and recursively walks through the AST for src and executes cb on every node.

stopWalking()

• Halts further walking of the AST until another manual call of walk.
• This is super-beneficial when dealing with large source files

traverse(node, cb)

• Allows you to traverse an AST node and execute a callback on it
• Callback should expect the first argument to be an AST node, similar to walk's callback.