jodit 3.8.5 → 3.9.2

package/src/core/dom.ts

@@ -10,11 +10,14 @@ import type {
 	ICreate,
 	IJodit,
 	NodeCondition,
-	Nullable
+	Nullable,
+	IDictionary
 } from '../types';
 import * as consts from './constants';
 import {
+	$$,
 	asArray,
+	attr,
 	css,
 	dataBind,
 	error,
@@ -26,6 +29,8 @@ import {
 	toArray,
 	trim
 } from './helpers';
+import { Select } from './selection';
+import { TEMP_ATTR } from './constants';
 
 /**
  * Module for working with DOM
@@ -33,7 +38,6 @@ import {
 export class Dom {
 	/**
 	 * Remove all content from element
-	 * @param node
 	 */
 	static detach(node: Node): void {
 		while (node.firstChild) {
@@ -43,10 +47,6 @@ export class Dom {
 
 	/**
 	 * Wrap all inline siblings
-	 *
-	 * @param current
-	 * @param tag
-	 * @param editor
 	 */
 	static wrapInline(
 		current: Node,
@@ -107,10 +107,6 @@ export class Dom {
 
 	/**
 	 * Wrap node inside another node
-	 *
-	 * @param current
-	 * @param tag
-	 * @param editor
 	 */
 	static wrap<K extends HTMLTagNames>(
 		current: Node,
@@ -138,7 +134,6 @@ export class Dom {
 
 	/**
 	 * Remove parent of node and insert this node instead that parent
-	 * @param node
 	 */
 	static unwrap(node: Node): void {
 		const parent = node.parentNode;
@@ -152,52 +147,8 @@ export class Dom {
 		}
 	}
 
-	/**
-	 * It goes through all the internal elements of the node, causing a callback function
-	 *
-	 * @param elm elements , the internal node is necessary to sort out
-	 * @param callback It called for each item found
-	 * @example
-	 * ```javascript
-	 * Jodit.modules.Dom.each(parent.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
-	 *  }
-	 * });
-	 * ```
-	 */
-	static each(
-		elm: Node | HTMLElement,
-		callback: (node: Node) => void | boolean
-	): boolean {
-		let node: Node | null | false = elm.firstChild;
-
-		if (node) {
-			while (node) {
-				const next = Dom.next(node, Boolean, elm);
-
-				if (callback(node) === false) {
-					return false;
-				}
-
-				// inside callback - node could be removed
-				if (node.parentNode && !Dom.each(node, callback)) {
-					return false;
-				}
-
-				node = next;
-			}
-		}
-
-		return true;
-	}
-
 	/**
 	 * Call function for all nodes between `start` and `end`
-	 *
-	 * @param start
-	 * @param end
 	 */
 	static between(
 		start: Node,
@@ -228,12 +179,10 @@ export class Dom {
 	/**
 	 * Replace one tag to another transfer content
 	 *
-	 * @param  {Node} elm The element that needs to be replaced by new
-	 * @param  {string} newTagName tag name for which will change `elm`
-	 * @param  {boolean} withAttributes=false If true move tag's attributes
-	 * @param  {boolean} notMoveContent=false false - Move content from elm to newTagName
-	 * @param  {Document} [doc=document]
-	 * @return {Node} Returns a new tag
+	 * @param elm - The element that needs to be replaced by new
+	 * @param newTagName - tag name for which will change `elm`
+	 * @param withAttributes - If true move tag's attributes
+	 * @param notMoveContent - false - Move content from elm to newTagName
 	 * @example
 	 * ```javascript
 	 * Jodit.modules.Dom.replace(parent.editor.getElementsByTagName('span')[0], 'p');
@@ -274,8 +223,7 @@ export class Dom {
 	 * Checks whether the Node text and blank (in this case it may contain invisible auxiliary characters ,
 	 * it is also empty )
 	 *
-	 * @param  {Node} node The element of wood to be checked
-	 * @return {Boolean} true element is empty
+	 * @param node - The element of wood to be checked
 	 */
 	static isEmptyTextNode(node: Node): boolean {
 		return (
@@ -288,10 +236,6 @@ export class Dom {
 
 	/**
 	 * Check if element is empty
-	 *
-	 * @param {Node} node
-	 * @param {RegExp} condNoEmptyElement
-	 * @return {boolean}
 	 */
 	static isEmpty(
 		node: Node,
@@ -345,7 +289,6 @@ export class Dom {
 
 	/**
 	 *  Check if element is table cell
-	 * @param elm
 	 */
 	static isCell(elm: unknown): elm is HTMLTableCellElement {
 		return Dom.isNode(elm) && /^(td|th)$/i.test(elm.nodeName);
@@ -353,9 +296,6 @@ export class Dom {
 
 	/**
 	 * Check is element is Image element
-	 *
-	 * @param {Node} elm
-	 * @return {boolean}
 	 */
 	static isImage(elm: unknown): elm is HTMLImageElement {
 		return (
@@ -378,7 +318,6 @@ export class Dom {
 
 	/**
 	 * Check if element is text node
-	 * @param node
 	 */
 	static isText(node: Node | null | false): node is Text {
 		return Boolean(node && node.nodeType === Node.TEXT_NODE);
@@ -386,11 +325,8 @@ export class Dom {
 
 	/**
 	 * Check if element is element node
-	 * @param node
 	 */
-	static isElement(
-		node: Node | null | false | EventTarget | object
-	): node is Element {
+	static isElement(node: unknown): node is Element {
 		if (!Dom.isNode(node)) {
 			return false;
 		}
@@ -402,7 +338,6 @@ export class Dom {
 
 	/**
 	 * Check if element is HTMLElement node
-	 * @param node
 	 */
 	static isHTMLElement(node: unknown): node is HTMLElement {
 		if (!Dom.isNode(node)) {
@@ -416,7 +351,6 @@ export class Dom {
 
 	/**
 	 * Check element is inline block
-	 * @param node
 	 */
 	static isInlineBlock(node: Node | null | false): node is HTMLElement {
 		return (
@@ -444,9 +378,6 @@ export class Dom {
 
 	/**
 	 * Get last matched node inside root
-	 *
-	 * @param root
-	 * @param condition
 	 */
 	static last(
 		root: Nullable<Node>,
@@ -489,50 +420,26 @@ export class Dom {
 
 	/**
 	 * Find previous node
-	 *
-	 * @param node
-	 * @param condition
-	 * @param root
-	 * @param [withChild]
 	 */
-	static prev(
+	static prev<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: Node | HTMLElement | ParentNode,
+		root: HTMLElement,
 		withChild: boolean = true
-	): Nullable<Node> {
-		return Dom.find(
-			node,
-			condition,
-			root,
-			false,
-			'previousSibling',
-			withChild ? 'lastChild' : false
-		);
+	): Nullable<T> {
+		return Dom.find<T>(node, condition, root, false, withChild);
 	}
 
 	/**
 	 * Find next node what `condition(next) === true`
-	 *
-	 * @param node
-	 * @param condition
-	 * @param root
-	 * @param [withChild]
 	 */
-	static next(
+	static next<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: Node | HTMLElement | ParentNode,
+		root: HTMLElement,
 		withChild: boolean = true
-	): Nullable<Node> {
-		return Dom.find(
-			node,
-			condition,
-			root,
-			undefined,
-			undefined,
-			withChild ? 'firstChild' : false
-		);
+	): Nullable<T> {
+		return Dom.find<T>(node, condition, root, true, withChild);
 	}
 
 	static prevWithClass(
@@ -563,69 +470,127 @@ export class Dom {
 
 	/**
 	 * Find next/prev node what `condition(next) === true`
-	 *
-	 * @param node
-	 * @param condition
-	 * @param root
-	 * @param [recurse] check first argument
-	 * @param [sibling] nextSibling or previousSibling
-	 * @param [child] firstChild or lastChild
 	 */
-	static find(
+	static find<T extends Node = Node>(
 		node: Node,
 		condition: NodeCondition,
-		root: ParentNode | HTMLElement | Node,
-		recurse = false,
-		sibling: keyof Node = 'nextSibling',
-		child: keyof Node | false = 'firstChild'
-	): Nullable<Node> {
-		if (recurse && condition(node)) {
-			return node;
+		root: HTMLElement,
+		leftToRight: boolean = true,
+		withChild: boolean = true
+	): Nullable<T> {
+		const gen = this.nextGen(node, root, leftToRight, withChild);
+
+		let item = gen.next();
+
+		while (!item.done) {
+			if (condition(item.value)) {
+				return <T>item.value;
+			}
+
+			item = gen.next();
 		}
 
-		let start: Nullable<Node> = node,
-			next: Nullable<Node>;
+		return null;
+	}
+
+	/**
+	 * Find next/prev node what `condition(next) === true`
+	 */
+	static *nextGen(
+		start: Node,
+		root: HTMLElement,
+		leftToRight: boolean = true,
+		withChild: boolean = true
+	): Generator<Node> {
+		const stack: Node[] = [];
+
+		let currentNode = start;
 
 		do {
-			next = start[sibling] as Node;
+			let next = leftToRight
+				? currentNode.nextSibling
+				: currentNode.previousSibling;
 
-			if (condition(next)) {
-				return next ? next : null;
+			while (next) {
+				stack.unshift(next);
+				next = leftToRight ? next.nextSibling : next.previousSibling;
 			}
 
-			if (child && next && next[child]) {
-				const nextOne = Dom.find(
-					next[child] as Node,
-					condition,
-					next,
-					true,
-					sibling,
-					child
-				);
+			yield* this.runInStack(start, stack, leftToRight, withChild);
 
-				if (nextOne) {
-					return nextOne;
-				}
+			currentNode = <Node>currentNode.parentNode;
+		} while (currentNode !== root);
+
+		return null;
+	}
+
+	/**
+	 * It goes through all the internal elements of the node, causing a callback function
+	 *
+	 * @param elm - the element whose children and descendants you want to iterate over
+	 * @param callback - It called for each item found
+	 * @example
+	 * ```javascript
+	 * Jodit.modules.Dom.each(parent.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
+	 *  }
+	 * });
+	 * ```
+	 */
+	static each(
+		elm: Node,
+		callback: (node: Node) => void | boolean,
+		leftToRight: boolean = true
+	): boolean {
+		const gen = this.eachGen(elm, leftToRight);
+
+		let item = gen.next();
+
+		while (!item.done) {
+			if (callback(item.value) === false) {
+				return false;
 			}
 
-			if (!next) {
-				next = start.parentNode;
+			item = gen.next();
+		}
+
+		return true;
+	}
+
+	static eachGen(root: Node, leftToRight: boolean = true): Generator<Node> {
+		return this.runInStack(root, [root], leftToRight);
+	}
+
+	private static *runInStack(
+		start: Node,
+		stack: Node[],
+		leftToRight: boolean,
+		withChild: boolean = true
+	): Generator<Node> {
+		while (stack.length) {
+			const item = <Node>stack.pop();
+
+			if (start !== item) {
+				yield item;
 			}
 
-			start = next;
-		} while (start && start !== root);
+			if (withChild) {
+				let child = leftToRight ? item.lastChild : item.firstChild;
 
-		return null;
+				while (child) {
+					stack.push(child);
+					child = leftToRight
+						? child.previousSibling
+						: child.nextSibling;
+				}
+			}
+		}
 	}
 
 	/**
 	 * Find next/prev node what `condition(next) === true`
-	 *
-	 * @param node
-	 * @param condition
-	 * @param root
-	 * @param [sibling] nextSibling or previousSibling
-	 * @param [child] firstChild or lastChild
 	 */
 	static findWithCurrent(
 		node: Node,
@@ -669,10 +634,6 @@ export class Dom {
 
 	/**
 	 * Get not empty  sibling
-	 *
-	 * @param node
-	 * @param [left]
-	 * @param [cond]
 	 */
 	static findSibling(
 		node: Node,
@@ -694,11 +655,6 @@ export class Dom {
 
 	/**
 	 * It goes through all the elements in ascending order, and checks to see if they meet the predetermined condition
-	 *
-	 * @param node
-	 * @param condition
-	 * @param [root] Root element
-	 * @param [checkRoot]
 	 */
 	static up<T extends HTMLElement>(
 		node: Nullable<Node>,
@@ -733,10 +689,6 @@ export class Dom {
 
 	/**
 	 * Find parent by tag name
-	 *
-	 * @param node
-	 * @param tags
-	 * @param root
 	 */
 	static closest<T extends HTMLElement, K extends HTMLTagNames>(
 		node: Nullable<Node>,
@@ -784,10 +736,6 @@ export class Dom {
 
 	/**
 	 * Furthest parent node matching condition
-	 *
-	 * @param node
-	 * @param condition
-	 * @param root
 	 */
 	static furthest<T extends HTMLElement>(
 		node: Nullable<Node>,
@@ -807,8 +755,6 @@ export class Dom {
 
 	/**
 	 * Append new element in the start of root
-	 * @param root
-	 * @param newElement
 	 */
 	static appendChildFirst(
 		root: HTMLElement,
@@ -827,9 +773,6 @@ export class Dom {
 
 	/**
 	 * Insert newElement after element
-	 *
-	 * @param elm
-	 * @param newElement
 	 */
 	static after(elm: Node, newElement: Node | DocumentFragment): void {
 		const { parentNode } = elm;
@@ -847,9 +790,6 @@ export class Dom {
 
 	/**
 	 * Insert newElement before element
-	 *
-	 * @param elm
-	 * @param newElement
 	 */
 	static before(elm: Node, newElement: Node | DocumentFragment): void {
 		const { parentNode } = elm;
@@ -863,9 +803,6 @@ export class Dom {
 
 	/**
 	 * Insert newElement as first child inside element
-	 *
-	 * @param elm
-	 * @param newElement
 	 */
 	static prepend(root: Node, newElement: Node | DocumentFragment): void {
 		root.insertBefore(newElement, root.firstChild);
@@ -873,9 +810,6 @@ export class Dom {
 
 	/**
 	 * Insert newElement as last child inside element
-	 *
-	 * @param elm
-	 * @param newElement
 	 */
 	static append(
 		root: Node,
@@ -899,10 +833,6 @@ export class Dom {
 
 	/**
 	 * Move all content to another element
-	 *
-	 * @param from
-	 * @param to
-	 * @param inStart
 	 */
 	static moveContent(from: Node, to: Node, inStart: boolean = false): void {
 		const fragment: DocumentFragment = (
@@ -922,10 +852,6 @@ export class Dom {
 
 	/**
 	 * Call callback condition function for all elements of node
-	 *
-	 * @param node
-	 * @param condition
-	 * @param prev
 	 */
 	static all(
 		node: Node,
@@ -951,10 +877,6 @@ export class Dom {
 
 	/**
 	 * Check root contains child or equal child
-	 *
-	 * @param root
-	 * @param child
-	 * @param [onlyContains]
 	 */
 	static isOrContains(
 		root: Node,
@@ -972,7 +894,6 @@ export class Dom {
 
 	/**
 	 * Safe remove element from DOM
-	 * @param node
 	 */
 	static safeRemove(node: Node | false | null | void): void {
 		node && node.parentNode && node.parentNode.removeChild(node);
@@ -980,7 +901,6 @@ export class Dom {
 
 	/**
 	 * Hide element
-	 * @param node
 	 */
 	static hide(node: Nullable<HTMLElement>): void {
 		if (!node) {
@@ -993,7 +913,6 @@ export class Dom {
 
 	/**
 	 * Show element
-	 * @param node
 	 */
 	static show(node: Nullable<HTMLElement>): void {
 		if (!node) {
@@ -1009,9 +928,6 @@ export class Dom {
 
 	/**
 	 * Check if element is some tag
-	 *
-	 * @param node
-	 * @param tagNames
 	 */
 	static isTag<K extends keyof HTMLElementTagNameMap>(
 		node: Node | null | false | EventTarget,
@@ -1040,4 +956,44 @@ export class Dom {
 
 		return false;
 	}
+
+	/**
+	 * Marks an item as temporary
+	 */
+	static markTemporary<K extends HTMLElement>(
+		element: K,
+		attributes?: IDictionary
+	): K {
+		attributes && attr(element, attributes);
+		attr(element, TEMP_ATTR, true);
+		return element;
+	}
+
+	/**
+	 * Check if element is temporary
+	 */
+	static isTemporary(element: unknown): boolean {
+		if (!Dom.isElement(element)) {
+			return false;
+		}
+
+		return Select.isMarker(element) || attr(element, TEMP_ATTR) === 'true';
+	}
+
+	/**
+	 * Replace temporary elements from string
+	 */
+	static replaceTemporaryFromString(value: string): string {
+		return value.replace(
+			/<([a-z]+)[^>]+data-jodit-temp[^>]+>(.+?)<\/\1>/gi,
+			'$2'
+		);
+	}
+
+	/**
+	 * Get temporary list
+	 */
+	static temporaryList(root: HTMLElement): HTMLElement[] {
+		return $$(`[${TEMP_ATTR}]`, root);
+	}
 }