@swagger-api/apidom-ast

@swagger-api/apidom-ast contains tools necessary for parsing stage of ApiDOM, specifically for syntactic analysis.
Syntactic analysis will take a stream of tokens and turn it into an AST representation.
Using the information in the tokens, this phase will reformat them as an AST which represents
the structure of input string in a way that makes it easier to work with.

@swagger-api/apidom-ast currently contains AST nodes for JSON and YAML 1.2 formats.

Installation

You can install this package via npm CLI by running the following command:

``sh
$ npm install @swagger-api/apidom-ast
`

Base AST Nodes

Base AST nodes are nodes that are supplementary to any specific AST nodes.
Having standardized AST of various formats (JSON/YAML) allows us to have common
syntactic analysis or transformation algorithms.
These nodes includes Error, Literal, Position, etc...

Along with base nodes there are predicates that can assert on these nodes.

JSON AST Nodes

Convenient for low lever CST parsers that don't come with it's onw AST nodes.
You can find list of JSON AST nodes in this directory.

YAML AST Nodes

Convenient for low lever CST parsers that don't come with it's onw AST nodes.
You can find list of YAML AST nodes in this directory.
As YAML is very complex format, along with nodes we also expose implementation of YAML Failsafe and JSON schemas
along with formatters for canonical block scalars.

Traversal

@swagger-api/apidom-ast comes with its own traversal algorithm convenient for traversing CST or AST.

$3

visit will walk through an CST/AST using a depth first traversal, calling
the visitor's enter function at each node in the traversal, and calling the
leave function after visiting that node and all of its child nodes.

By returning different values from the enter and leave functions, the
behavior of the visitor can be altered, including skipping over a sub-tree of
the Node (by returning false), editing the Node Tree by returning a value or null
to remove the value, or to stop the whole traversal by returning BREAK.

When using visit to edit an Node Tree, the original Node Tree will not be modified, and
a new version of the Node Tree with the changes applied will be returned from the
visit function.

`js
import { visit } from '@swagger-api/apidom-ast';

const tree = {
type: 'root',
children: [
{
type: 'child',
value: 'this is child node',
children: [],
},
],
};

const keyMap = {
root: ['children'],
};

const visitor = {
child(node) {
console.dir(node.value); // => 'this is child node'
},
};

const newTree = visit(tree, visitor, { keyMap }); // => tree{...}
`

Notice how we used 3rd parameter to visit function. Actually it can consume number of configuration
options which can change its behavior.

Configuration option | Type | Default | Description
--- | --- | --- | ---
keyMap | Object | null | Defines how nodes map to it's children.
state | Object | {} | Additional state that is provided to the visitor. State is merged inti visitor object in following manner: Object.assign(visitor, state)
breakSymbol | Object | {} | Defines a symbol that can break the traversal. Symbol is compared by strict equality (===).
visitFnGetter | Function | getVisitFn | Function that extract appropriate method from the visitor given specific Node type.
nodeTypeGetter | Function | getNodeType | Node type extractor function.
nodePredicate | Function | isNode | Predicate that checks if particular Node can be really considered a Node.
detectCycles | Boolean | true | If the structure that needs to be traversed is represented as directed cyclic graph, visit` will skip Nodes that have already been traversed to avoid infinite recursion.