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

node-source-walk

Execute a callback on every node of a file'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
  // or the AST of an outside parse of myfile.js

  walker.walk(src, function (node) {
    if (/* some condition */) {
      // No need to keep traversing since we found what we wanted
      walker.stopWalking();
    }
  });

By default, Walker will use babylon (supporting ES6, JSX, Flow, and all other available babylon plugins) and the sourceType: module, but you can change any of the defaults as follows:

var walker = new Walker({
  sourceType: 'script',
  // If you don't like experimental plugins
  plugins: [
    'jsx',
    'flow'
  ]
});

• The supplied options are passed through to the parser, so you can configure it according to babylon's documentation: https://github.com/babel/babylon

Public Members

walk(src, cb)

• src: the contents of a file OR its (already parsed) AST
• cb: a function that is called for every visited 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.