File size: 5,671 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
# Node API
- [Static methods](node.md#static-methods)
- [Retrieval methods](node.md#retrieval-methods)
- [Text methods](node.md#text-methods)
- [Check methods](node.md#check-methods)
## Static methods
### Retrieval methods
#### `Node.ancestor(root: Node, path: Path) => Ancestor`
Get the node at a specific `path`, asserting that it is an ancestor node. If the specified node is not an ancestor node, throw an error.
#### `Node.ancestors(root: Node, path: Path, options?) => Generator<NodeEntry<Ancestor>>`
Return a generator of all the ancestor nodes above a specific path. By default, the order is top-down, from highest to lowest ancestor in the tree, but you can pass the `reverse: true` option to go bottom-up.
Options: `{reverse?: boolean}`
#### `Node.child(root: Node, index: number) => Descendant`
Get the child of a node at the specified `index`.
#### `Node.children(root: Node, path: Path, options?) => Generator<NodeEntry<Descendant>>`
Iterate over the children of a node at a specific path.
Options: `{reverse?: boolean}`
#### `Node.common(root: Node, path: Path, another: Path) => NodeEntry`
Get an entry for the common ancestor node of two paths. It might be a Text node, an Element, or the Editor itself.
For the common block ancestor, see [Editor Selection](https://docs.slatejs.org/concepts/03-locations#selection)
#### `Node.descendant(root: Node, path: Path) => Descendant`
Get the node at a specific path, asserting that it's a descendant node.
#### `Node.descendants(root: Node, options?) => Generator<NodeEntry<Descendant>>`
Return a generator of all the descendant node entries inside a root node. Each iteration will return a `NodeEntry` tuple consisting of `[Node, Path]`.
Options: `{from?: Path, to?: Path, reverse?: boolean, pass?: (node: NodeEntry => boolean)}`
#### `Node.elements(root: Node, options?) => Generator<ElementEntry>`
Return a generator of all the element nodes inside a root node. Each iteration will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the root node is an element, it will be included in the iteration as well.
Options: `{from?: Path, to?: Path, reverse?: boolean, pass?: (node: NodeEntry => boolean)}`
#### `Node.extractProps(node: Node) => NodeProps`
Extract all properties from a Node except for its content-related fields (`children` for Element nodes and `text` for Text nodes).
```typescript
// For an Element node
const element = {
type: 'paragraph',
align: 'center',
children: [{ text: 'Try it out for yourself!' }],
}
const props = Node.extractProps(element)
// Returns: { type: 'paragraph', align: "center" }
// For a Text node
const text = { text: 'Hello', bold: true }
const props = Node.extractProps(text)
// Returns: { bold: true }
```
#### `Node.first(root: Node, path: Path) => NodeEntry`
Get the first node entry in a root node from a `path`.
#### `Node.fragment(root: Node, range: Range) => Descendant[]`
Get the sliced fragment represented by the `range`.
#### `Node.get(root: Node, path: Path) => Node`
Get the descendant node referred to by a specific `path`. If the path is an empty array, get the root node itself.
#### `Node.getIf(root: Node, path: Path) => Node | undefined`
Get a descendant node at a specific path, returning `undefined` if the node does not exist. This is a safer alternative to `Node.get()` as it won't throw an error if the path is invalid.
```typescript
const node = Node.getIf(root, [0, 1])
if (node) {
// node exists at path [0, 1]
} else {
// no node exists at path [0, 1]
}
```
#### `Node.last(root: Node, path: Path) => NodeEntry`
Get the last node entry in a root node at a specific `path`.
#### `Node.leaf(root: Node, path: Path) => Text`
Get the node at a specific `path`, ensuring it's a leaf text node. If the node is not a leaf text node, throw an error.
#### `Node.levels(root: Node, path: Path, options?) => Generator<NodeEntry>`
Return a generator of the nodes in a branch of the tree, from a specific `path`. By default, the order is top-down, from the highest to the lowest node in the tree, but you can pass the `reverse: true` option to go bottom-up.
Options: `{reverse?: boolean}`
#### `Node.nodes(root: Node, options?) => Generator<NodeEntry>`
Return a generator of all the node entries of a root node. Each entry is returned as a `[Node, Path]` tuple, with the path referring to the node's position inside the root node.
Options: `{from?: Path, to?: Path, reverse?: boolean, pass?: (node: NodeEntry => boolean)}`
#### `Node.parent(root: Node, path: Path) => Ancestor`
Get the parent of a node at a specific `path`.
### Text methods
Methods related to Text.
#### `Node.string(root: Node) => string`
Get the concatenated text string of a node's content. Note that this will not include spaces or line breaks between block nodes. This is not intended as a user-facing string, but as a string for performing offset-related computations for a node.
#### `Node.texts(root: Node, options?) => Generator<NodeEntry<Text>>`
Return a generator of all leaf text nodes in a root node.
Options: `{from?: Path, to?: Path, reverse?: boolean, pass?: (node: NodeEntry => boolean)}`
### Check methods
Methods used to check some attribute of a Node.
#### `Node.has(root: Node, path: Path) => boolean`
Check if a descendant node exists at a specific `path`.
#### `Node.isNode(value: any) => value is Node`
Check if a `value` implements the `Node` interface.
#### `Node.isNodeList(value: any) => value is Node[]`
Check if a `value` is a list of `Node` objects.
#### `Node.matches(root: Node, props: Partial<Node>) => boolean`
Check if a node matches a set of `props`.
|