Class NodeAdapterAbstract

constructor

• new NodeAdapter(positionOverride?): NodeAdapter

• Parameters

  • Optional positionOverride: Position

  Returns NodeAdapter

Optional destination

Optional origin

Optional parseTree

children

• get children(): Node[]

• Returns Node[]

features

• get features(): FeatureDescription[]

• Returns FeatureDescription[]

position

• get position(): undefined | Position

• Returns undefined | Position

• set position(newPos): void

• Parameters

  • newPos: undefined | Position

  Returns void

source

• get source(): undefined | Source

• Returns undefined | Source

sourceText

• get sourceText(): undefined | string

• Returns undefined | string

addChild

• addChild(name, child): void

• Parameters

  • name: string | symbol
  • child: Node

  Returns void

containment

• containment(name): undefined | Feature

• Parameters

  • name: string | symbol

  Returns undefined | Feature

contains

• contains(position?): boolean

• Tests whether the given position is contained in the interval represented by this object.

  Parameters

  • Optional position: Position

    the position

  Returns boolean

find

• find(predicate, walker?): undefined | Node

• Finds the first node that satisfies a condition among this node's descendants.

  Parameters

  • predicate: ((n, index) => boolean)

    the function expressing the condition that the node must satisfy.

    • • (n, index): boolean

      • Parameters

        • n: Node
        • index: number

        Returns boolean

  • Optional walker: ((node) => Generator<Node>)

    the function that generates the nodes to operate on in the desired sequence. By default, this is a depth-first traversal that includes the node on which find() has been called.

    • • (node): Generator<Node>

      • A generator that walks the whole AST starting from the provided node, depth-first.

        Parameters

        • node: Node

          the starting node.

        Returns Generator<Node>

  Returns undefined | Node

  the first node in the AST for which the predicate is true. Returns undefined if none are found.

findAncestorOfType

• findAncestorOfType(type): undefined | Node

• Note that the type is not strictly forced to be a subclass of Node. This is intended to support interfaces like Statement or Expression. However, being an ancestor the returned value is guaranteed to be a Node, as only Node instances can be part of the hierarchy.

  Parameters

  • type: any

  Returns undefined | Node

  ancestor the nearest ancestor of this node that is of type type.

findByPosition

• findByPosition(position, selfContained?): undefined | Node

• Parameters

  • position: Position

    the position where to search for nodes
  • Optional selfContained: boolean

    whether the starting node position contains the positions of all its children. If true no further search will be performed in subtrees where the root node falls outside the given position. If false (default) the research will cover all nodes from the starting node to the leaves.

  Returns undefined | Node

  the node most closely containing the given [position]. undefined if none is found.

  See

  searchByPosition

getAllChildren

• getAllChildren(): Node[]

• Returns Node[]

getAttributeValue

• getAttributeValue(name): any

• Parameters

  • name: string | symbol

  Returns any

getChild

• getChild(name, index?): undefined | Node

• Parameters

  • name: string | symbol
  • Optional index: number

  Returns undefined | Node

getChildNames

• getChildNames(): string[]

• Returns string[]

getChildrenWithRole

• getChildrenWithRole(name): Node[]

• Parameters

  • name: string | symbol

  Returns Node[]

getReference

• getReference(name): undefined | ReferenceByName<any>

• Parameters

  • name: string | symbol

  Returns undefined | ReferenceByName<any>

hasValidParents

• hasValidParents(parent?): boolean

• Parameters

  • Optional parent: Node

  Returns boolean

invalidPositions

• invalidPositions(): Generator<Node, any, unknown>

• Returns Generator<Node, any, unknown>

overlaps

• overlaps(position?): boolean

• Tests whether the given position overlaps the interval represented by this object.

  Parameters

  • Optional position: Position

    the position

  Returns boolean

replaceWith

• replaceWith(other): void

• Replace the current Node with another Node

  Parameters

  • other: Node

  Returns void

  Throws

  Error - if this.parent === undefined

searchByPosition

• searchByPosition(position, selfContained?): Generator<Node, any, unknown>

• Parameters

  • position: Position

    the position where to search for nodes
  • Optional selfContained: boolean

    whether the starting node position contains the positions of all its children. If true: no further search will be performed in subtrees where the root node falls outside the given position.

    • If false (default): the search will cover all nodes from the starting node to the leaves. In any case, the search stops at the first subtree found to be containing the position.

  Returns Generator<Node, any, unknown>

  all nodes containing the given [position] using depth-first search. Empty list if none are found.

setAttributeValue

• setAttributeValue(name, value): void

• Parameters

  • name: string | symbol
  • value: any

  Returns void

setChild

• setChild(name, child): void

• Parameters

  • name: string | symbol
  • child: Node

  Returns void

transformChildren

• transformChildren(operation): void

• Apply the given operation function to all of the Node's children.

  It's possible to use both pure functions, to replace the nodes, and functions that mutate the nodes in-place.

  Parameters

  • operation: ((node) => Node)
    • • (node): Node

      • Parameters

        • node: Node

        Returns Node

  Returns void

walk

• walk(): Generator<Node, any, unknown>

• A generator that walks over the whole AST starting from this node, depth-first.

  Returns Generator<Node, any, unknown>

walkAncestors

• walkAncestors(): Generator<Node, any, unknown>

• Returns Generator<Node, any, unknown>

  nodes the sequence of nodes from the parent all the way up to the root node. For this to work, the nodes' parents must have been set.

walkChildren

• walkChildren(): Generator<Node, any, unknown>

• A generator that walks over the direct children of this node.

  Returns Generator<Node, any, unknown>

walkDescendants

• walkDescendants(walker?): Generator<Node, any, unknown>

• A generator that walks over the whole AST starting from the children of this node.

  Parameters

  • Optional walker: ((node) => Generator<Node>)

    a function that generates a sequence of nodes. By default, this is the depth-first "walk" function. For post-order traversal, use "walkLeavesFirst".

    • • (node): Generator<Node>

      • A generator that walks the whole AST starting from the provided node, depth-first.

        Parameters

        • node: Node

          the starting node.

        Returns Generator<Node>

  Returns Generator<Node, any, unknown>

walkWithin

• walkWithin(position): Generator<Node, any, unknown>

• Parameters

  • position: Position

    the position within which the walk should remain

  Returns Generator<Node, any, unknown>

  walks the AST within the given [position] starting from this node, depth-first.

withOrigin

• withOrigin(origin?): this

• Parameters

  • Optional origin: Origin

  Returns this

withParent

• withParent(parent?): this

• Parameters

  • Optional parent: Node

  Returns this

withParseTreeNode

• withParseTreeNode(parseTree?, source?): this

• Parameters

  • Optional parseTree: null | ParseTree
  • Optional source: Source

  Returns this