Dom | Jodit Editor

Module for working with DOM

Hierarchy

Methods

`Static` after

after(elm: Node, newElement: Node | DocumentFragment): void
Insert newElement after element
Parameters
- elm: Node
- newElement: Node | DocumentFragment
Returns void

`Static` append

append(root: Node, newElements: (Node | DocumentFragment)[]): void
Insert newElement as last child inside element
Parameters
- root: Node
- newElements: (Node | DocumentFragment)[]
Returns void
append(root: Node, newElement: Node | DocumentFragment): void
Parameters
- root: Node
- newElement: Node | DocumentFragment
Returns void

`Static` appendChildFirst

appendChildFirst(root: HTMLElement, newElement: HTMLElement | DocumentFragment): void
Append new element in the start of root
Parameters
- root: HTMLElement
- newElement: HTMLElement | DocumentFragment
Returns void

`Static` before

before(elm: Node, newElement: Node | DocumentFragment): void
Insert newElement before element
Parameters
- elm: Node
- newElement: Node | DocumentFragment
Returns void

`Static` between

between(start: Node, end: Node, callback: ((node: Node) => boolean | void)): void
Call functions for all nodes between start and end
Parameters
- start: Node
- end: Node
- callback: ((node: Node) => boolean | void)
  - - (node: Node): boolean | void
    - Parameters
      
      node: Node
      
      Returns boolean | void
Returns void

`Static` canSplitBlock

canSplitBlock(node: unknown): boolean
It's block and it can be split
Parameters
- node: unknown
Returns boolean

`Static` closest

closest<T, K>(node: Nullable<Node>, tags: K, root: HTMLElement): Nullable<HTMLElementTagNameMap[K]>
Find parent by tag name
Type Parameters
- T extends HTMLElement<T>
- K extends keyof HTMLElementTagNameMap
Parameters
- node: Nullable<Node>
- tags: K
- root: HTMLElement
Returns Nullable<HTMLElementTagNameMap[K]>
closest<T, K>(node: Nullable<Node>, tags: K[], root: HTMLElement): Nullable<HTMLElementTagNameMap[K]>
Type Parameters
- T extends HTMLElement<T>
- K extends keyof HTMLElementTagNameMap
Parameters
- node: Nullable<Node>
- tags: K[]
- root: HTMLElement
Returns Nullable<HTMLElementTagNameMap[K]>
closest<T>(node: Nullable<Node>, condition: NodeCondition<Node>, root: HTMLElement): Nullable<T>
Type Parameters
- T extends HTMLElement<T>
Parameters
- node: Nullable<Node>
- condition: NodeCondition<Node>
- root: HTMLElement
Returns Nullable<T>

`Static` detach

detach(node: Node): void
Remove all content from element
Parameters
- node: Node
Returns void

`Static` each

each(elm: Node, callback: ((node: Node) => boolean | void), leftToRight?: boolean): boolean
It goes through all the internal elements of the node, causing a callback function

Example
```
Jodit.modules.Dom.each(editor.s.current(), function (node) {
 if (node.nodeType === Node.TEXT_NODE) {
     node.nodeValue = node.nodeValue.replace(Jodit.INVISIBLE_SPACE_REG_EX, '') // remove all of the text element codes invisible character
 }
});
```
Parameters
- elm: Node
  
  the element whose children and descendants you want to iterate over
- callback: ((node: Node) => boolean | void)
  
  It called for each item found
  - - (node: Node): boolean | void
    - Parameters
      
      node: Node
      
      Returns boolean | void
- leftToRight: boolean = true
Returns boolean

`Static` eachGen

eachGen(root: Node, leftToRight?: boolean): Generator<Node, any, unknown>
Parameters
- root: Node
- leftToRight: boolean = true
Returns Generator<Node, any, unknown>

`Static` find

find<T>(node: Node, condition: NodeCondition<Node>, root: HTMLElement, leftToRight?: boolean, withChild?: boolean): Nullable<T>
Find next/prev node what condition(next) === true
Type Parameters
- T extends Node<T> = Node
Parameters
- node: Node
- condition: NodeCondition<Node>
- root: HTMLElement
- leftToRight: boolean = true
- withChild: boolean = true
Returns Nullable<T>

`Static` findNotEmptyNeighbor

findNotEmptyNeighbor(node: Node, left: boolean, root: HTMLElement): Nullable<Node>
Returns the nearest non-empty neighbor
Parameters
- node: Node
- left: boolean
- root: HTMLElement
Returns Nullable<Node>

`Static` findNotEmptySibling

findNotEmptySibling(node: Node, left: boolean): Nullable<Node>
Returns the nearest non-empty sibling
Parameters
- node: Node
- left: boolean
Returns Nullable<Node>

`Static` findSibling

findSibling(node: Node, left?: boolean, cond?: ((n: Node) => boolean)): Nullable<Node>
Get not empty sibling
Parameters
- node: Node
- left: boolean = true
- cond: ((n: Node) => boolean) = ...
  - - (n: Node): boolean
    - Parameters
      
      n: Node
      
      Returns boolean
Returns Nullable<Node>

`Static` findWithCurrent

findWithCurrent(node: Node, condition: NodeCondition<Node>, root: Node | HTMLElement, sibling?: "nextSibling" | "previousSibling", child?: "firstChild" | "lastChild"): Nullable<Node>
Find next/prev node what condition(next) === true
Parameters
- node: Node
- condition: NodeCondition<Node>
- root: Node | HTMLElement
- sibling: "nextSibling" | "previousSibling" = 'nextSibling'
- child: "firstChild" | "lastChild" = 'firstChild'
Returns Nullable<Node>

`Static` furthest

furthest<T>(node: Nullable<Node>, condition: NodeCondition<Node>, root: HTMLElement): Nullable<T>
Furthest parent node matching condition
Type Parameters
- T extends HTMLElement<T>
Parameters
- node: Nullable<Node>
- condition: NodeCondition<Node>
- root: HTMLElement
Returns Nullable<T>

`Static` hide

hide(node: Nullable<HTMLElement>): void
Hide element
Parameters
- node: Nullable<HTMLElement>
Returns void

`Static` isBlock

isBlock(node: unknown): node is HTMLDivElement
Check the node is a block element
Parameters
- node: unknown
  
  Object to check
Returns node is HTMLDivElement

`Static` isCell

isCell(elm: unknown): elm is HTMLTableCellElement
Check if element is table cell
Parameters
- elm: unknown
Returns elm is HTMLTableCellElement

`Static` isContentEditable

isContentEditable(node: Nullable<Node>, root: HTMLElement): boolean
The node is editable
Parameters
- node: Nullable<Node>
- root: HTMLElement
Returns boolean

`Static` isElement

isElement(node: unknown): node is Element
Check if element is element node
Parameters
- node: unknown
Returns node is Element

`Static` isEmpty

isEmpty(node: Node, condNoEmptyElement: ((node: Element) => boolean)): boolean
Check if element is empty
Parameters
- node: Node
- condNoEmptyElement: ((node: Element) => boolean)
  - - (node: Element): boolean
    - Parameters
      
      node: Element
      
      Returns boolean
Returns boolean
isEmpty(node: Node, noEmptyTags?: Set<string>): boolean
Parameters
- node: Node
- Optional noEmptyTags: Set<string>
Returns boolean

`Static` isEmptyContent

isEmptyContent(node: Node): boolean
Parameters
- node: Node
Returns boolean

`Static` isEmptyTextNode

isEmptyTextNode(node: Nullable<Node>): boolean
Checks whether the Node text and blank (in this case it may contain invisible auxiliary characters , it is also empty )
Parameters
- node: Nullable<Node>
  
  The element of wood to be checked
Returns boolean

`Static` isFragment

isFragment(node: unknown): node is DocumentFragment
Check if element is document fragment
Parameters
- node: unknown
Returns node is DocumentFragment

`Static` isHTMLElement

isHTMLElement(node: unknown): node is HTMLElement
Check if element is HTMLElement node
Parameters
- node: unknown
Returns node is HTMLElement

`Static` isImage

isImage(elm: unknown): elm is HTMLImageElement
Check is element is Image element
Parameters
- elm: unknown
Returns elm is HTMLImageElement

`Static` isInlineBlock

isInlineBlock(node: null | false | Node): node is HTMLElement
Check element is inline block
Parameters
- node: null | false | Node
Returns node is HTMLElement

`Static` isNode

isNode(object: unknown): object is Node
Returns true if it is a DOM node
Parameters
- object: unknown
Returns object is Node

`Static` isOrContains

isOrContains(root: Node, child: Node, onlyContains?: boolean): boolean
Check root contains child or equal child
Parameters
- root: Node
- child: Node
- onlyContains: boolean = false
Returns boolean

`Static` isTag

isTag<K>(node: undefined | null | false | EventTarget | Node, tagName: K): node is HTMLElementTagNameMap[K]
Check if element is some tag
Type Parameters
- K extends keyof HTMLElementTagNameMap
Parameters
- node: undefined | null | false | EventTarget | Node
- tagName: K
Returns node is HTMLElementTagNameMap[K]
isTag<K>(node: undefined | null | false | EventTarget | Node, tagNames: K[]): node is HTMLElementTagNameMap[K]
Type Parameters
- K extends keyof HTMLElementTagNameMap
Parameters
- node: undefined | null | false | EventTarget | Node
- tagNames: K[]
Returns node is HTMLElementTagNameMap[K]
isTag<K>(node: undefined | null | false | EventTarget | Node, tagNames: Set<K>): node is HTMLElementTagNameMap[K]
Type Parameters
- K extends keyof HTMLElementTagNameMap
Parameters
- node: undefined | null | false | EventTarget | Node
- tagNames: Set<K>
Returns node is HTMLElementTagNameMap[K]

`Static` isTemporary

isTemporary(element: unknown): boolean
Check if element is temporary
Parameters
- element: unknown
Returns boolean

`Static` isText

isText(node: null | false | Node): node is Text
Check if element is text node
Parameters
- node: null | false | Node
Returns node is Text

`Static` last

last(root: Nullable<Node>, condition: NodeCondition<Node>): Nullable<Node>
Get last matched node inside root
Parameters
- root: Nullable<Node>
- condition: NodeCondition<Node>
Returns Nullable<Node>

`Static` markTemporary

markTemporary<K>(element: K, attributes?: IDictionary<any, string>): K
Marks an item as temporary
Type Parameters
- K extends HTMLElement<K>
Parameters
- element: K
- Optional attributes: IDictionary<any, string>
Returns K

`Static` moveContent

moveContent(from: Node, to: Node, inStart?: boolean, filter?: ((node: Node) => boolean)): void
Move all content to another element
Parameters
- from: Node
- to: Node
- inStart: boolean = false
- filter: ((node: Node) => boolean) = ...
  - - (node: Node): boolean
    - Parameters
      
      node: Node
      
      Returns boolean
Returns void

`Static` next

next<T>(node: Node, condition: NodeCondition<Node>, root: HTMLElement, withChild?: boolean): Nullable<T>
Find next node what condition(next) === true
Type Parameters
- T extends Node<T> = Node
Parameters
- node: Node
- condition: NodeCondition<Node>
- root: HTMLElement
- withChild: boolean = true
Returns Nullable<T>

`Static` nextGen

nextGen(start: Node, root: HTMLElement, leftToRight?: boolean, withChild?: boolean): Generator<Node, any, unknown>
Find next/prev node what condition(next) === true
Parameters
- start: Node
- root: HTMLElement
- leftToRight: boolean = true
- withChild: boolean = true
Returns Generator<Node, any, unknown>

`Static` nextWithClass

nextWithClass(node: HTMLElement, className: string): Nullable<HTMLElement>
Parameters
- node: HTMLElement
- className: string
Returns Nullable<HTMLElement>

`Static` prepend

prepend(root: Node, newElement: Node | DocumentFragment): void
Insert newElement as first child inside element
Parameters
- root: Node
- newElement: Node | DocumentFragment
Returns void

`Static` prev

prev<T>(node: Node, condition: NodeCondition<Node>, root: HTMLElement, withChild?: boolean): Nullable<T>
Find previous node
Type Parameters
- T extends Node<T> = Node
Parameters
- node: Node
- condition: NodeCondition<Node>
- root: HTMLElement
- withChild: boolean = true
Returns Nullable<T>

`Static` prevWithClass

prevWithClass(node: HTMLElement, className: string): Nullable<HTMLElement>
Parameters
- node: HTMLElement
- className: string
Returns Nullable<HTMLElement>

`Static` replace

replace<T>(elm: Node, newTagName: keyof HTMLElementTagNameMap, create: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T
Replace one tag to another transfer content

Example
```
Jodit.modules.Dom.replace(parent.editor.getElementsByTagName('span')[0], 'p');
// Replace the first <span> element to the < p >
```
Type Parameters
- T extends HTMLElement<T>
Parameters
- elm: Node
  
  The element that needs to be replaced by new
- newTagName: keyof HTMLElementTagNameMap
  
  tag name for which will change elm
- create: ICreate
- Optional withAttributes: boolean
  
  If true move tag's attributes
- Optional notMoveContent: boolean
  
  false - Move content from elm to newTagName
Returns T
replace<T>(elm: Node, newTagName: string | T, create: ICreate, withAttributes?: boolean, notMoveContent?: boolean): T
Type Parameters
- T extends Node<T>
Parameters
- elm: Node
- newTagName: string | T
- create: ICreate
- Optional withAttributes: boolean
- Optional notMoveContent: boolean
Returns T

`Static` replaceTemporaryFromString

replaceTemporaryFromString(value: string): string
Replace temporary elements from string
Parameters
- value: string
Returns string

`Static` safeInsertNode

safeInsertNode(range: Range, node: Node): void
Parameters
- range: Range
- node: Node
Returns void

`Static` safeRemove

safeRemove(...nodes: unknown[]): void
Safe remove element from DOM
Parameters
- Rest ...nodes: unknown[]
Returns void

`Static` show

show(node: Nullable<HTMLElement>): void
Show element
Parameters
- node: Nullable<HTMLElement>
Returns void

`Static` sibling

sibling(node: Node, left?: boolean): Nullable<Node>
Parameters
- node: Node
- Optional left: boolean
Returns Nullable<Node>

`Static` temporaryList

temporaryList(root: HTMLElement): HTMLElement[]
Get temporary list
Parameters
- root: HTMLElement
Returns HTMLElement[]

`Static` unwrap

unwrap(node: Node): void
Remove parent of node and insert this node instead that parent
Parameters
- node: Node
Returns void

`Static` up

up<T>(node: Nullable<Node>, condition: NodeCondition<Node>, root?: Node, checkRoot?: boolean): Nullable<T>
It goes through all the elements in ascending order, and checks to see if they meet the predetermined condition
Type Parameters
- T extends HTMLElement<T>
Parameters
- node: Nullable<Node>
- condition: NodeCondition<Node>
- Optional root: Node
- checkRoot: boolean = false
Returns Nullable<T>

`Static` wrap

wrap<K>(current: Node | Range, tag: HTMLElement, create: ICreate): HTMLElementTagNameMap[K]
Wrap node inside another node
Type Parameters
- K extends keyof HTMLElementTagNameMap
Parameters
- current: Node | Range
- tag: HTMLElement
- create: ICreate
Returns HTMLElementTagNameMap[K]
wrap<K>(current: Node | Range, tag: K, create: ICreate): HTMLElementTagNameMap[K]
Wrap node inside another node
Type Parameters
- K extends keyof HTMLElementTagNameMap
Parameters
- current: Node | Range
- tag: K
- create: ICreate
Returns HTMLElementTagNameMap[K]

`Static` wrapInline

wrapInline(current: Node, tag: Node | keyof HTMLElementTagNameMap, editor: IJodit): HTMLElement
Wrap all inline siblings
Parameters
- current: Node
- tag: Node | keyof HTMLElementTagNameMap
- editor: IJodit
Returns HTMLElement

Hierarchy

Index

Methods

Constructors

Methods

Static after

Parameters

elm: Node

newElement: Node | DocumentFragment

Returns void

Static append

Parameters

root: Node

newElements: (Node | DocumentFragment)[]

Returns void

Parameters

root: Node

newElement: Node | DocumentFragment

Returns void

Static appendChildFirst

Parameters

root: HTMLElement

newElement: HTMLElement | DocumentFragment

Returns void

Static before

Parameters

elm: Node

newElement: Node | DocumentFragment

Returns void

Static between

Parameters

start: Node

end: Node

callback: ((node: Node) => boolean | void)

Parameters

node: Node

Returns boolean | void

Returns void

Static canSplitBlock

Parameters

node: unknown

Returns boolean

Static closest

Type Parameters

T extends HTMLElement<T>

K extends keyof HTMLElementTagNameMap

Parameters

node: Nullable<Node>

tags: K

root: HTMLElement

Returns Nullable<HTMLElementTagNameMap[K]>

Type Parameters

T extends HTMLElement<T>

K extends keyof HTMLElementTagNameMap

Parameters

node: Nullable<Node>

tags: K[]

root: HTMLElement

Returns Nullable<HTMLElementTagNameMap[K]>

Type Parameters

T extends HTMLElement<T>

Parameters

node: Nullable<Node>

condition: NodeCondition<Node>

root: HTMLElement

Returns Nullable<T>

Static detach

Parameters

node: Node

Returns void

Static each

Example

Parameters

elm: Node

callback: ((node: Node) => boolean | void)

Parameters

node: Node

Returns boolean | void

leftToRight: boolean = true

Returns boolean

`Static` after

`Static` append

`Static` appendChildFirst

`Static` before

`Static` between

`Static` canSplitBlock

`Static` closest

`Static` detach

`Static` each

`Static` eachGen

`Static` find

`Static` findNotEmptyNeighbor

`Static` findNotEmptySibling

`Static` findSibling

`Static` findWithCurrent

`Static` furthest

`Static` hide

`Static` isBlock

`Static` isCell

`Static` isContentEditable

`Static` isElement