ProsemirrorEx.Model.Node (prosemirror_ex v0.3.0)

Represents a ProseMirror document node. It holds a type, optional attributes, a content Fragment, marks, and (for text nodes) text.

Summary

Functions

can_append(node, other)

Test whether the given node's content can be appended to this node. If that node's content is not empty, this is equivalent to checking whether the content can be inserted at the end.

can_replace(node, from, to, replacement \\ nil, start \\ 0, end_val \\ nil)

Test whether replacing the range from..to (child indices) in this node with the given replacement fragment would leave the node's content valid. start and end_val optionally restrict which part of the replacement is considered.

can_replace_with(node, from, to, type, marks \\ nil)

Test whether replacing the range from..to (child indices) with a node of the given type would leave the node's content valid.

check(node)

Check that this node's content is valid for its type.

child(node, index)

Get the child node at the given index. Raises on out-of-range.

child_after(node, pos)

Find the child node after the given position. Returns {node, index, offset}.

child_before(node, pos)

Find the child node before the given position. Returns {node, index, offset}.

child_count(node)

The number of children that this node has.

children(node)

The list of children of this node.

content_match_at(node, index)

Return a content match state that represents the match after the first index children of this node.

copy(node, content)

Create a copy of this node with the given content.

cut(node, from, to \\ nil)

Cut the text or content of this node between the given positions.

debug_string(node)

A human-readable debug representation of this node (equivalent to JS toString).

descendants(node, f)

Call the given function for all descendant nodes.

eq(a, b)

Test whether this node is the same as another node (structurally equal).

first_child(node)

Get the first child of this node, or nil.

fold_descendants(node, acc, f)

Fold over all descendant nodes, threading an accumulator.

for_each(node, f)

Call f for each child node, passing (node, offset, index).

from_json(schema, json)

Deserialize a node from its JSON representation.

has_markup(node, type, attrs \\ nil, marks \\ nil)

Test whether this node has the given type, attributes, and marks.

inline_content(node)

True when this node allows inline content.

is_atom_node(node)

True when this is an atom node (a leaf node that is treated as a single unit).

is_block(node)

True when this is a block node.

is_inline(node)

True when this is an inline node.

is_leaf(node)

True when this is a leaf node.

is_text(node)

True when this is a text node.

is_textblock(node)

True when this is a textblock node (a block that contains inline content).

last_child(node)

Get the last child of this node, or nil.

mark(node, marks)

Create a copy of this node with a different set of marks.

maybe_child(node, index)

Get the child node at the given index, or nil if out of range.

node_at(node, pos)

Find the node at the given position.

node_size(node)

The size of this node as counted by the indexing scheme. For text nodes this is the text length, for leaf nodes it is 1, and for non-leaf nodes it is the content size + 2 (for the open and close tokens).

nodes_between(node, from, to, f, start_pos \\ 0)

Invoke a callback for all descendant nodes between the given positions (relative to the start of this node's content). Passes the node, its absolute position, its parent node, and its index into the parent's child list.

range_has_mark(node, from, to, mark_or_type)

Test whether the given range contains a mark of the given type.

replace(node, from, to \\ nil, slice \\ nil)

Replace a range of the document with the given slice.

resolve(doc, pos)

Resolve the given position in this document, returning a ResolvedPos.

same_markup(a, b)

Test whether the markup (type, attributes, marks) of this node is the same as that of another.

slice(node, from, to \\ nil, include_parents \\ false)

Extract a slice of the document between the given positions.

text_between(node, from, to, block_sep \\ "", leaf_text \\ nil)

Get the text between from and to positions within this node.

text_content(node)

Get the text content of this node.

to_json(node)

Serialize this node to JSON.

with_text(node, text)

Create a text node with the same type, attributes, and marks but different text.

Types

t()

@type t() :: %ProsemirrorEx.Model.Node{
  attrs: term(),
  content: term(),
  marks: term(),
  text: term(),
  type: term()
}