Utils library for ProseMirror (forked for ES modules)
npm install prosemirror-utils-bangleThis is a fork of https://github.com/atlassian/prosemirror-utils
I forked it to make it easier to use with ES modules and a modern bundling.







Install prosemirror-utils package from npm:
``sh`
npm install prosemirror-utils
* findParentNode(predicate: fn(node: ProseMirrorNode) → boolean) → fn(selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}\predicate
Iterates over parent nodes, returning the closest node and its start position returns truthy for. start points to the start position of the node, pos points directly before the node.
`javascript`
const predicate = node => node.type === schema.nodes.blockquote;
const parent = findParentNode(predicate)(selection);
* findParentNodeClosestToPos($pos: ResolvedPos, predicate: fn(node: ProseMirrorNode) → boolean) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}\$pos
Iterates over parent nodes starting from the given , returning the closest node and its start position predicate returns truthy for. start points to the start position of the node, pos points directly before the node.
`javascript`
const predicate = node => node.type === schema.nodes.blockquote;
const parent = findParentNodeClosestToPos(state.doc.resolve(5), predicate);
* findParentDomRef(predicate: fn(node: ProseMirrorNode) → boolean, domAtPos: fn(pos: number) → {node: dom.Node, offset: number}) → fn(selection: Selection) → ?dom.Node\predicate
Iterates over parent nodes, returning DOM reference of the closest node returns truthy for.
` * * dispatch( - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0javascript
const domAtPos = view.domAtPos.bind(view);
const predicate = node => node.type === schema.nodes.table;
const parent = findParentDomRef(predicate, domAtPos)(selection); //
`hasParentNode
* (predicate: fn(node: ProseMirrorNode) → boolean) → fn(selection: Selection) → boolean\predicate
Checks if there's a parent node returns truthy for.`javascript`
if (hasParentNode(node => node.type === schema.nodes.table)(selection)) {
// ....
}
findParentNodeOfType
* (nodeType: NodeType | [NodeType]) → fn(selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}\nodeType
Iterates over parent nodes, returning closest node of a given . start points to the start position of the node, pos points directly before the node.`javascript`
const parent = findParentNodeOfType(schema.nodes.paragraph)(selection);
findParentNodeOfTypeClosestToPos
* ($pos: ResolvedPos, nodeType: NodeType | [NodeType]) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}\$pos
Iterates over parent nodes starting from the given , returning closest node of a given nodeType. start points to the start position of the node, pos points directly before the node.`javascript`
const parent = findParentNodeOfTypeClosestToPos(state.doc.resolve(10), schema.nodes.paragraph);
hasParentNodeOfType
* (nodeType: NodeType | [NodeType]) → fn(selection: Selection) → boolean\nodeType
Checks if there's a parent node of a given .`javascript`
if (hasParentNodeOfType(schema.nodes.table)(selection)) {
// ....
}
findParentDomRefOfType
* (nodeType: NodeType | [NodeType], domAtPos: fn(pos: number) → {node: dom.Node, offset: number}) → fn(selection: Selection) → ?dom.Node\nodeType
Iterates over parent nodes, returning DOM reference of the closest node of a given .`javascript`
const domAtPos = view.domAtPos.bind(view);
const parent = findParentDomRefOfType(schema.nodes.codeBlock, domAtPos)(selection); //
findSelectedNodeOfType
* (nodeType: NodeType | [NodeType]) → fn(selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}\nodeType
Returns a node of a given if it is selected. start points to the start position of the node, pos points directly before the node.`javascript`
const { extension, inlineExtension, bodiedExtension } = schema.nodes;
const selectedNode = findSelectedNodeOfType([
extension,
inlineExtension,
bodiedExtension,
])(selection);
isNodeSelection
* (selection: Selection) → boolean\NodeSelection
Checks if current selection is a .`javascript`
if (isNodeSelection(tr.selection)) {
// ...
}
findPositionOfNodeBefore
* (selection: Selection) → ?number\`
Returns position of the previous node.javascript`
const pos = findPositionOfNodeBefore(tr.selection);
findDomRefAtPos
* (position: number, domAtPos: fn(pos: number) → {node: dom.Node, offset: number}) → dom.Node\position
Returns DOM reference of a node at a given . If the node type is of type TEXT_NODE it will return the reference of the parent node.`javascript`
const domAtPos = view.domAtPos.bind(view);
const ref = findDomRefAtPos($from.pos, domAtPos);
flatten$3
(node: ProseMirrorNode, descend: ?boolean = true) → [{node: ProseMirrorNode, pos: number}]\node
Flattens descendants of a given . It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const children = flatten(node);
findChildren
* (node: ProseMirrorNode, predicate: fn(node: ProseMirrorNode) → boolean, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Iterates over descendants of a given , returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const textNodes = findChildren(node, child => child.isText, false);
findTextNodes
* (node: ProseMirrorNode, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Returns text nodes of a given . It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const textNodes = findTextNodes(node);
findInlineNodes
* (node: ProseMirrorNode, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Returns inline nodes of a given . It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const inlineNodes = findInlineNodes(node);
findBlockNodes
* (node: ProseMirrorNode, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Returns block descendants of a given . It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const blockNodes = findBlockNodes(node);
findChildrenByAttr
* (node: ProseMirrorNode, predicate: fn(attrs: ?Object) → boolean, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Iterates over descendants of a given , returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const mergedCells = findChildrenByAttr(table, attrs => attrs.colspan === 2);
findChildrenByType
* (node: ProseMirrorNode, nodeType: NodeType, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Iterates over descendants of a given , returning child nodes of a given nodeType. It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const cells = findChildrenByType(table, schema.nodes.tableCell);
findChildrenByMark
* (node: ProseMirrorNode, markType: markType, descend: ?boolean) → [{node: ProseMirrorNode, pos: number}]\node
Iterates over descendants of a given , returning child nodes that have a mark of a given markType. It doesn't descend into a node when descend argument is false (defaults to true).`javascript`
const nodes = findChildrenByMark(state.doc, schema.marks.strong);
contains
* (node: ProseMirrorNode, nodeType: NodeType) → boolean\true
Returns if a given node contains nodes of a given nodeType`javascript`
if (contains(panel, schema.nodes.listItem)) {
// ...
}
removeParentNodeOfType$3
(nodeType: NodeType | [NodeType]) → fn(tr: Transaction) → Transaction\nodeType
Returns a new transaction that removes a node of a given . It will return an original transaction if parent node hasn't been found.`javascript`
dispatch(
removeParentNodeOfType(schema.nodes.table)(tr)
);
replaceParentNodeOfType
* (nodeType: NodeType | [NodeType], content: ProseMirrorNode | Fragment) → fn(tr: Transaction) → Transaction\nodeType
Returns a new transaction that replaces parent node of a given with the given content. It will return an original transaction if either parent node hasn't been found or replacing is not possible.`javascript`
const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));
replaceParentNodeOfType(schema.nodes.table, node)(tr)
);
removeSelectedNode
* (tr: Transaction) → Transaction\NodeSelection
Returns a new transaction that removes selected node. It will return an original transaction if current selection is not a .`javascript`
dispatch(
removeSelectedNode(tr)
);
replaceSelectedNode
* (content: ProseMirrorNode | ProseMirrorFragment) → fn(tr: Transaction) → Transaction\node
Returns a new transaction that replaces selected node with a given , keeping NodeSelection on the new node.`
It will return the original transaction if either current selection is not a NodeSelection or replacing is not possible.javascript`
const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));
dispatch(
replaceSelectedNode(node)(tr)
);
canInsert
* ($pos: ResolvedPos, content: ProseMirrorNode | Fragment) → boolean\content
Checks if a given can be inserted at the given $pos`javascript`
const { selection: { $from } } = state;
const node = state.schema.nodes.atom.createChecked();
if (canInsert($from, node)) {
// ...
}
safeInsert
* (content: ProseMirrorNode | Fragment, position: ?number, tryToReplace: ?boolean) → fn(tr: Transaction) → Transaction\content
Returns a new transaction that inserts a given at the current cursor position, or at a given position, if it is allowed by schema. If schema restricts such nesting, it will try to find an appropriate place for a given node in the document, looping through parent nodes up until the root document node.tryToReplace
If is true and current selection is a NodeSelection, it will replace selected node with inserted content if its allowed by schema.`
If cursor is inside of an empty paragraph, it will try to replace that paragraph with the given content. If insertion is successful and inserted node has content, it will set cursor inside of that content.
It will return an original transaction if the place for insertion hasn't been found.javascript`
const node = schema.nodes.extension.createChecked({});
dispatch(
safeInsert(node)(tr)
);
setParentNodeMarkup
* (nodeType: NodeType | [NodeType], type: ?NodeType | null, attrs: ?Object | null, marks: ?[Mark]) → fn(tr: Transaction) → Transaction\nodeType
Returns a transaction that changes the type, attributes, and/or marks of the parent node of a given .`javascript`
const node = schema.nodes.extension.createChecked({});
dispatch(
setParentNodeMarkup(schema.nodes.panel, null, { panelType })(tr);
);
selectParentNodeOfType
* (nodeType: NodeType | [NodeType]) → fn(tr: Transaction) → Transaction\NodeSelection
Returns a new transaction that sets a on a parent node of a given nodeType.`javascript`
dispatch(
selectParentNodeOfType([tableCell, tableHeader])(state.tr)
);
removeNodeBefore
* (tr: Transaction) → Transaction\`
Returns a new transaction that deletes previous node.javascript`
dispatch(
removeNodeBefore(state.tr)
);
setTextSelection
* (position: number, dir: ?number = 1) → fn(tr: Transaction) → Transaction\position
Returns a new transaction that tries to find a valid cursor selection starting at the given dir
and searching back if is negative, and forward if positive.`
If a valid cursor position hasn't been found, it will return the original transaction.javascript``
dispatch(
setTextSelection(5)(tr)
);
License