unist-util-select

What is unist-util-select?

The unist-util-select package is a utility for selecting nodes in a Unist syntax tree using CSS-like selectors. It allows for querying and manipulating nodes in a tree structure, making it easier to work with abstract syntax trees (ASTs) in JavaScript.

What are unist-util-select's main functionalities?

Select a single node

This feature allows you to select a single node from the tree that matches the given selector. In this example, it selects the first 'paragraph' node in the tree.

const select = require('unist-util-select').select;
const tree = { type: 'root', children: [{ type: 'paragraph', children: [{ type: 'text', value: 'Hello, world!' }] }] };
const node = select('paragraph', tree);
console.log(node);

Select multiple nodes

This feature allows you to select all nodes from the tree that match the given selector. In this example, it selects all 'paragraph' nodes in the tree.

const selectAll = require('unist-util-select').selectAll;
const tree = { type: 'root', children: [{ type: 'paragraph', children: [{ type: 'text', value: 'Hello, world!' }] }, { type: 'paragraph', children: [{ type: 'text', value: 'Another paragraph.' }] }] };
const nodes = selectAll('paragraph', tree);
console.log(nodes);

Select nodes with specific attributes

This feature allows you to select nodes that have specific attributes. In this example, it selects all nodes with a 'data-id' attribute equal to 'intro'.

const selectAll = require('unist-util-select').selectAll;
const tree = { type: 'root', children: [{ type: 'paragraph', data: { id: 'intro' }, children: [{ type: 'text', value: 'Introduction' }] }, { type: 'paragraph', data: { id: 'main' }, children: [{ type: 'text', value: 'Main content' }] }] };
const nodes = selectAll('[data-id="intro"]', tree);
console.log(nodes);

Other packages similar to unist-util-select

unist-util-visit

unist-util-visit is a utility for recursively visiting nodes in a Unist syntax tree. It allows for more complex traversal and manipulation of nodes compared to unist-util-select, but does not use CSS-like selectors.

hast-util-select

hast-util-select is similar to unist-util-select but is specifically designed for working with HAST (Hypertext Abstract Syntax Tree) nodes. It provides CSS-like selectors for querying HAST nodes.

unist-builder

unist-builder is a utility for creating Unist syntax trees. While it does not provide querying capabilities like unist-util-select, it is useful for constructing trees programmatically.

README

unist-util-select

unist utility with equivalents for querySelector, querySelectorAll, and matches.

Note that the DOM has references to their parent nodes, meaning that document.body.matches(':last-child') can be evaluated. This information is not stored in unist, so selectors like that don’t work.

View the list of supported selectors »

Install

This package is ESM only: Node 12+ is needed to use it and it must be imported instead of required.

npm:

npm install unist-util-select

API

This package exports the following identifiers: matches, select, selectAll. There is no default export.

matches(selector, node)

Check that the given node matches selector. Returns boolean, whether the node matches or not.

This only checks the element itself, not the surrounding tree. Thus, nesting in selectors is not supported (paragraph strong, paragraph > strong), nor are selectors like :first-child, etc. This only checks that the given element matches the selector.

import {u} from 'unist-builder'
import {matches} from 'unist-util-select'

matches('strong, em', u('strong', [u('text', 'important')])) // => true
matches('[lang]', u('code', {lang: 'js'}, 'console.log(1)')) // => true

select(selector, tree)

Select the first node matching selector in the given tree (could be the tree itself). Returns the found node, if any.

import {u} from 'unist-builder'
import {select} from 'unist-util-select'

console.log(
  select(
    'code ~ :nth-child(even)',
    u('blockquote', [
      u('paragraph', [u('text', 'Alpha')]),
      u('paragraph', [u('text', 'Bravo')]),
      u('code', 'Charlie'),
      u('paragraph', [u('text', 'Delta')]),
      u('paragraph', [u('text', 'Echo')])
    ])
  )
)

Yields:

{type: 'paragraph', children: [{type: 'text', value: 'Delta'}]}

selectAll(selector, tree)

Select all nodes matching selector in the given tree (could include the tree itself). Returns all found nodes, if any.

import {u} from 'unist-builder'
import {selectAll} from 'unist-util-select'

console.log(
  selectAll(
    'code ~ :nth-child(even)',
    u('blockquote', [
      u('paragraph', [u('text', 'Alpha')]),
      u('paragraph', [u('text', 'Bravo')]),
      u('code', 'Charlie'),
      u('paragraph', [u('text', 'Delta')]),
      u('paragraph', [u('text', 'Echo')]),
      u('paragraph', [u('text', 'Foxtrot')]),
      u('paragraph', [u('text', 'Golf')])
    ])
  )
)

Yields:

[
  {type: 'paragraph', children: [{type: 'text', value: 'Delta'}]},
  {type: 'paragraph', children: [{type: 'text', value: 'Foxtrot'}]}
]

Support

• * (universal selector)
• , (multiple selector)
• paragraph (type selector)
• blockquote paragraph (combinator: descendant selector)
• blockquote > paragraph (combinator: child selector)
• code + paragraph (combinator: adjacent sibling selector)
• code ~ paragraph (combinator: general sibling selector)
• [attr] (attribute existence, checks that the value on the tree is not nullish)
• [attr=value] (attribute equality, this stringifies values on the tree)
• [attr^=value] (attribute begins with, only works on strings)
• [attr$=value] (attribute ends with, only works on strings)
• [attr*=value] (attribute contains, only works on strings)
• [attr~=value] (attribute contains, checks if value is in the array, if there’s an array on the tree, otherwise same as attribute equality)
• :any() (functional pseudo-class, use :matches instead)
• :has() (functional pseudo-class) Relative selectors (:has(> img)) are not supported, but :scope is
• :matches() (functional pseudo-class)
• :not() (functional pseudo-class)
• :blank (pseudo-class, blank and empty are the same: a parent without children, or a node without value)
• :empty (pseudo-class, blank and empty are the same: a parent without children, or a node without value)
• :root (pseudo-class, matches the given node)
• :scope (pseudo-class, matches the given node)
• * :first-child (pseudo-class)
• * :first-of-type (pseudo-class)
• * :last-child (pseudo-class)
• * :last-of-type (pseudo-class)
• * :only-child (pseudo-class)
• * :only-of-type (pseudo-class)
• * :nth-child() (functional pseudo-class)
• * :nth-last-child() (functional pseudo-class)
• * :nth-last-of-type() (functional pseudo-class)
• * :nth-of-type() (functional pseudo-class)

Notes

• * — Not supported in matches

Related

• unist-util-filter — Create a new tree with all nodes that pass a test
• unist-util-map — Create a new tree with all nodes mapped by a given function
• unist-util-flatmap — Create a new tree by mapping (to an array) with the given function
• unist-util-is — Check if a node passes a test
• unist-util-remove — Remove nodes from trees
• unist-util-remove-position — Remove positional info from trees
• unist-util-visit — Recursively walk over nodes
• unist-util-visit-parents — Like visit, but with a stack of parents
• unist-builder — Helper for creating trees

Contribute

See contributing.md in syntax-tree/.github for ways to get started. See support.md for ways to get help.

This project has a code of conduct. By interacting with this repository, organization, or community you agree to abide by its terms.

License

MIT © Eugene Sharygin