hast-util-is-element

What is hast-util-is-element?

The hast-util-is-element package is a utility for working with HAST (Hypertext Abstract Syntax Tree) nodes. It provides functions to check if a node is an element and optionally matches a given tag name. This is particularly useful when manipulating or inspecting HTML represented within JavaScript.

What are hast-util-is-element's main functionalities?

Check if a node is an element

This feature allows you to verify if a given node is an element node within a HAST structure. It's useful for filtering or processing nodes in a tree.

const isElement = require('hast-util-is-element');

const node = {type: 'element', tagName: 'div'};
console.log(isElement(node)); // Outputs: true

Check if a node is a specific element

This feature extends the basic check to allow for specification of the tag name. It's useful for finding or working with specific types of elements in a document.

const isElement = require('hast-util-is-element');

const node = {type: 'element', tagName: 'span'};
console.log(isElement(node, 'span')); // Outputs: true

Other packages similar to hast-util-is-element

unist-util-is

This package offers a more generalized approach for checking node types in unist trees, which is a part of the broader unified ecosystem. Unlike hast-util-is-element, unist-util-is can be used with different syntax trees beyond HTML, offering greater flexibility.

hast-util-has-property

Similar in utility scope within the HAST ecosystem, this package checks for the presence of properties in elements. While hast-util-is-element focuses on the type and tag name of nodes, hast-util-has-property deals with the properties of those nodes, providing a complementary functionality.

README

hast-util-is-element

hast utility to check if a node is a (certain) element.

Contents

• What is this?
• When should I use this?
• Install
• Use
• API
  • isElement(element[, test[, index, parent[, context]]])
  • convertElement(test)
  • Check
  • Test
  • TestFunction
• Types
• Compatibility
• Security
• Related
• Contribute
• License

What is this?

This package is a small utility that checks that a node is a certain element.

When should I use this?

Use this small utility if you find yourself repeating code for checking what elements nodes are.

A similar package, unist-util-is, works on any unist node.

For more advanced tests, hast-util-select can be used to match against CSS selectors.

Install

This package is ESM only. In Node.js (version 16+), install with npm:

npm install hast-util-is-element

In Deno with esm.sh:

import {isElement} from 'https://esm.sh/hast-util-is-element@3'

In browsers with esm.sh:

<script type="module">
  import {isElement} from 'https://esm.sh/hast-util-is-element@3?bundle'
</script>

Use

import {isElement} from 'hast-util-is-element'

isElement({type: 'text', value: 'foo'}) // => false
isElement({type: 'element', tagName: 'a', properties: {}, children: []}) // => true
isElement({type: 'element', tagName: 'a', properties: {}, children: []}, 'a') // => true
isElement({type: 'element', tagName: 'a', properties: {}, children: []}, 'b') // => false
isElement({type: 'element', tagName: 'a', properties: {}, children: []}, ['a', 'area']) // => true

API

This package exports the identifiers convertElement and isElement. There is no default export.

isElement(element[, test[, index, parent[, context]]])

Check if element is an Element and whether it passes the given test.

Parameters

• element (unknown, optional) — thing to check, typically Node
• test (Test, optional) — check for a specific element
• index (number, optional) — position of element in its parent
• parent (Parent, optional) — parent of element
• context (unknown, optional) — context object (this) to call test with

Returns

Whether element is an Element and passes a test (boolean).

Throws

When an incorrect test, index, or parent is given. There is no error thrown when element is not a node or not an element.

convertElement(test)

Generate a check from a test.

Useful if you’re going to test many nodes, for example when creating a utility where something else passes a compatible test.

The created function is a bit faster because it expects valid input only: a element, index, and parent.

Parameters

• test (Test, optional) — a test for a specific element

Returns

A check (Check).

Check

Check that an arbitrary value is an element (TypeScript type).

Parameters

• this (unknown, optional) — context object (this) to call test with
• element (unknown) — anything (typically an element)
• index (number, optional) — position of element in its parent
• parent (Parent, optional) — parent of element

Returns

Whether this is an element and passes a test (boolean).

Test

Check for an arbitrary element (TypeScript type).

• when string, checks that the element has that tag name
• when function, see TestFunction
• when Array, checks if one of the subtests pass

Type

type Test =
  | Array<TestFunction | string>
  | TestFunction
  | string
  | null
  | undefined

TestFunction

Check if an element passes a test (TypeScript type).

Parameters

• element (Element) — an element
• index (number or undefined) — position of element in its parent
• parent (Parent or undefined) — parent of element

Returns

Whether this element passes the test (boolean, optional).

Types

This package is fully typed with TypeScript. It exports the additional types Check, Test, and TestFunction.

Compatibility

Projects maintained by the unified collective are compatible with maintained versions of Node.js.

When we cut a new major release, we drop support for unmaintained versions of Node. This means we try to keep the current release line, hast-util-is-element@^3, compatible with Node.js 16.

Security

hast-util-is-element does not change the syntax tree so there are no openings for cross-site scripting (XSS) attacks.

Related

• hast-util-has-property — check if a node has a property
• hast-util-is-body-ok-link — check if a node is “Body OK” link element
• hast-util-is-conditional-comment — check if a node is a conditional comment
• hast-util-is-css-link — check if a node is a CSS link element
• hast-util-is-css-style — check if a node is a CSS style element
• hast-util-embedded — check if a node is an embedded element
• hast-util-heading — check if a node is a heading element
• hast-util-interactive — check if a node is interactive
• hast-util-is-javascript — check if a node is a JavaScript script element
• hast-util-labelable — check whether a node is labelable
• hast-util-phrasing — check if a node is phrasing content
• hast-util-script-supporting — check if a node is a script-supporting element
• hast-util-sectioning — check if a node is a sectioning element
• hast-util-transparent — check if a node is a transparent element
• hast-util-whitespace — check if a node is inter-element whitespace

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 © Titus Wormer