unist-util-types

unist utility types

Contents

• What is this?
• Install
• Use
• API
  • Ancestor<Tree, Child>
  • Children<T>
  • Decrement<[I]>
  • InclusiveDescendant<Tree[, Max][, Depth]>
  • Increment<[I]>
  • Index
  • IsAncestor<Tree, Child[, Max][, Depth]>
  • IsParent<Tree, Child>
  • Match<N, T>
  • MatchInclusiveDescendant<Tree, Check[, Max]>
  • Parents<Tree[, Child]>
  • PositionalInfo<[T]>
  • Test
  • TestFunction<[T][, P][, U]>
    • fn(node[, index][, parent])
  • Type<[T]>
  • Uint
• Contribute

What is this?

This package contains TypeScript definitions for working with unist and its ecosystem of utilities.

Install

This package is ESM only.

In Node.js (version 18+) with yarn:

yarn add -D @flex-development/unist-util-types @types/unist

Use

import type {
  Ancestor,
  Children,
  InclusiveDescendant,
  Index,
  Match,
  MatchInclusiveDescendant,
  Parents,
  PositionalInfo,
  Test,
  TestFunction,
  Type
} from '@flex-development/unist-util-types'

API

Ancestor<Tree, Child>

Collect nodes in Tree that can be ancestors of Child.

• Tree (Node): tree to collect ancestors from
• Child (Node): expected child node

source: src/ancestor.ts

Children<T>

Extract children from tree T.

• T (Node): tree to extract children from

source: src/children.ts

Decrement<[I]>

Subtract 1 from I while I is in the range [1, 10].

• I (Uint): number to subtract from
  • default: 10

source: src/decrement.ts

InclusiveDescendant<Tree[, Max][, Depth]>

Collect all inclusive descendants of Tree.

• Tree (Node): tree to collect descendants from
• Max (Uint): maximum search depth
  • default: 10
• Depth (Uint): current search depth
  • default: 0

source: src/descendant-inclusive.ts

Increment<[I]>

Add 1 to I while I is in the range [0, 9].

• I (Uint): number to add to
  • default: 0

source: src/increment.ts

Index

Number of preceding siblings of a child node.

source: src/index-number.ts

IsAncestor<Tree, Child[, Max][, Depth]>

Check if Tree is an ancestor of Child.

• Tree (Node): tree to check
• Child (Node): expected child node
• Max (Uint): maximum search depth
  • default: 10
• Depth (Uint): current search depth
  • default: 0

source: src/is-ancestor.ts

IsParent<Tree, Child>

Check if Tree is the parent of Child.

• Tree (Node): tree to check
• Child (Node): expected child node

source: src/is-parent.ts

Match<N, T>

Check if node N passes a test.

• N (Node): node to check
• T (Test): node test

source: src/match.ts

MatchInclusiveDescendant<Tree, Check[, Max]>

Check if inclusive descendants of Tree pass a test.

• Tree (Node): tree to check
• Check (Test): node test
• Max (Uint): maximum search depth
  • default: 10

source: src/src/match-descendant-inclusive.ts

Parents<Tree[, Child]>

Collect nodes in Tree that can be parents of Child.

All parents will be included in the resulting union if Child is any.

• Tree (Node): tree to collect parents from
• Child (Node): expected child node
  • default: any

source: src/parents.ts

PositionalInfo<[T]>

Object containing the positional information of tree T.

• T (Node): tree to get positional information from
  • default: Node

source: src/positional-info.ts

Test

Union of test types for a Node.

See unist-util-is for more details.

source: src/test.ts

TestFunction<[T][, P][, U]>

Check if a node passes a test.

• T (Node): node to check
  • default: Node
• P (Parent): parent(s) of node T
  • default: Parent
• U (any): this context
  • default: unknown

fn(node[, index][, parent])

Parameters:

• node (T): node to check
• index (Index | undefined): index of node in parent.children
• parent (Parent | undefined): parent of node

Returns:

boolean | undefined | void test result for node

source: src/test-function.ts

Type<[T]>

Extract type from tree T.

• T (Node): tree to extract type from
  • default: Node

source: src/type.ts

Uint

Number used for iteration.

Range: [0, 10]

source: src/uint.ts

Contribute

See CONTRIBUTING.md.

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