jodit 3.9.6 → 3.11.2

package/src/plugins/keyboard/backspace/cases/check-join-neighbors.ts

@@ -0,0 +1,117 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit, Nullable } from '../../../../types';
+import { findNotEmptySibling } from '../../helpers';
+import { Dom } from '../../../../core/dom';
+
+/**
+ * Check if two separate elements can be connected
+ */
+export function checkJoinNeighbors(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	let nextBox: Nullable<Node> = fakeNode,
+		mainClosestBox: Nullable<Node> = nextBox;
+
+	// Find main big closest element
+	while (
+		nextBox &&
+		!findNotEmptySibling(nextBox, backspace) &&
+		nextBox.parentElement !== jodit.editor
+	) {
+		nextBox = nextBox.parentElement;
+		mainClosestBox = nextBox;
+	}
+
+	if (
+		Dom.isElement(mainClosestBox) &&
+		Dom.isContentEditable(mainClosestBox, jodit.editor)
+	) {
+		const sibling = findNotEmptySibling(
+			mainClosestBox,
+			backspace
+		) as Nullable<Element>;
+
+		if (
+			sibling &&
+			(checkMoveListContent(jodit, mainClosestBox, sibling, backspace) ||
+				moveContentAndRemoveEmpty(
+					jodit,
+					mainClosestBox,
+					sibling,
+					backspace
+				))
+		) {
+			jodit.s.setCursorBefore(fakeNode);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function checkMoveListContent(
+	jodit: IJodit,
+	mainClosestBox: Element,
+	sibling: Element,
+	backspace: boolean
+): boolean {
+	// Process UL/LI/OL cases
+	const siblingIsList = Dom.isTag(sibling, ['ol', 'ul']);
+	const boxIsList = Dom.isTag(mainClosestBox, ['ol', 'ul']);
+	const elementChild = (elm: Element, side: boolean) =>
+		side ? elm.firstElementChild : elm.lastElementChild;
+
+	if (boxIsList) {
+		sibling = jodit.createInside.element(jodit.o.enterBlock);
+		Dom.before(mainClosestBox, sibling);
+
+		return moveContentAndRemoveEmpty(
+			jodit,
+			elementChild(mainClosestBox, backspace),
+			sibling,
+			backspace
+		);
+	}
+
+	if (sibling && siblingIsList && !boxIsList) {
+		return moveContentAndRemoveEmpty(
+			jodit,
+			mainClosestBox,
+			elementChild(sibling, !backspace),
+			backspace
+		);
+	}
+
+	return false;
+}
+
+function moveContentAndRemoveEmpty(
+	jodit: IJodit,
+	mainClosestBox: Nullable<Node>,
+	sibling: Nullable<Node>,
+	backspace: boolean
+): boolean {
+	// Move content and remove empty nodes
+	if (mainClosestBox && Dom.isElement(sibling)) {
+		Dom.moveContent(mainClosestBox, sibling, !backspace);
+
+		let remove: Nullable<Node> = mainClosestBox;
+
+		while (remove && remove !== jodit.editor && Dom.isEmpty(remove)) {
+			const parent: Nullable<Node> = remove.parentElement;
+			Dom.safeRemove(remove);
+			remove = parent;
+		}
+
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-join-two-lists.ts

@@ -0,0 +1,55 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { call } from '../../../../core/helpers';
+
+/**
+ * Try join two UL elements
+ *
+ * @example
+ * ```html
+ * <ul><li>one</li></ul>|<ol><li>two</li></ol>
+ * ```
+ * Result
+ * ```html
+ * <ul><li>one|</li><li>two</li></ul>
+ * ```
+ */
+export function checkJoinTwoLists(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	const next = Dom.findSibling(fakeNode, backspace),
+		prev = Dom.findSibling(fakeNode, !backspace);
+
+	if (
+		!Dom.closest(fakeNode, Dom.isElement, jodit.editor) &&
+		Dom.isTag(next, ['ul', 'ol']) &&
+		Dom.isTag(prev, ['ul', 'ol']) &&
+		Dom.isTag(next.lastElementChild, 'li') &&
+		Dom.isTag(prev.firstElementChild, 'li')
+	) {
+		const { setCursorBefore, setCursorAfter } = jodit.s;
+
+		const target = next.lastElementChild,
+			second = prev.firstElementChild;
+
+		call(!backspace ? Dom.append : Dom.prepend, second, fakeNode);
+
+		Dom.moveContent(prev, next, !backspace);
+		Dom.safeRemove(prev);
+
+		call(backspace ? Dom.append : Dom.prepend, target, fakeNode);
+		call(backspace ? setCursorBefore : setCursorAfter, fakeNode);
+
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-not-collapsed.ts

@@ -0,0 +1,27 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import type { IJodit } from '../../../../types';
+
+/**
+ * On Not collapsed selection - should only remove whole selected content
+ *
+ * @example
+ * ```html
+ * <p>first | stop</p><p>second | stop</p>
+ * ```
+ * result
+ * ```html
+ * <p>first | stop</p>
+ * ```
+ */
+export function checkNotCollapsed(jodit: IJodit): boolean {
+	if (!jodit.s.isCollapsed()) {
+		jodit.execCommand('Delete');
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-remove-char.ts

@@ -0,0 +1,191 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { CanUndef, IJodit, Nullable } from '../../../../types';
+import type { DeleteMode } from '../interface';
+import { findMostNestedNeighbor, getSibling } from '../../helpers';
+import { Dom } from '../../../../core/dom';
+import { call, isVoid, toArray, trimInv } from '../../../../core/helpers';
+import { INVISIBLE_SPACE, NBSP_SPACE } from '../../../../core/constants';
+
+/**
+ * Check possibility the char can be removed
+ *
+ * @example
+ * ```html
+ * te|st
+ * ```
+ * result
+ * ```html
+ * t|st
+ * ```
+ */
+export function checkRemoveChar(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean,
+	mode: DeleteMode
+): boolean {
+	const step = backspace ? -1 : 1;
+	const anotherSibling: Nullable<Node> = getSibling(fakeNode, !backspace);
+
+	let sibling: Nullable<Node> = getSibling(fakeNode, backspace),
+		removeNeighbor: Nullable<Node> = null;
+
+	let charRemoved: boolean = false,
+		removed: CanUndef<string>;
+
+	while (sibling && (Dom.isText(sibling) || Dom.isInlineBlock(sibling))) {
+		while (Dom.isInlineBlock(sibling)) {
+			sibling = (
+				backspace ? sibling?.lastChild : sibling?.firstChild
+			) as Nullable<Node>;
+		}
+
+		if (!sibling) {
+			break;
+		}
+
+		if (sibling.nodeValue?.length) {
+			// For Unicode escapes
+			let value = toArray(sibling.nodeValue);
+
+			const length = value.length;
+
+			let index = backspace ? length - 1 : 0;
+
+			if (value[index] === INVISIBLE_SPACE) {
+				while (value[index] === INVISIBLE_SPACE) {
+					index += step;
+				}
+			}
+
+			removed = value[index];
+
+			if (value[index + step] === INVISIBLE_SPACE) {
+				index += step;
+
+				while (value[index] === INVISIBLE_SPACE) {
+					index += step;
+				}
+
+				index += backspace ? 1 : -1;
+			}
+
+			if (backspace && index < 0) {
+				value = [];
+			} else {
+				value = value.slice(
+					backspace ? 0 : index + 1,
+					backspace ? index : length
+				);
+			}
+
+			if (
+				!anotherSibling ||
+				!Dom.isText(anotherSibling) ||
+				(!backspace ? / $/ : /^ /).test(
+					anotherSibling.nodeValue ?? ''
+				) ||
+				!trimInv(anotherSibling.nodeValue || '').length
+			) {
+				for (
+					let i = backspace ? value.length - 1 : 0;
+					backspace ? i >= 0 : i < value.length;
+					i += backspace ? -1 : 1
+				) {
+					if (value[i] === ' ') {
+						value[i] = NBSP_SPACE;
+					} else {
+						break;
+					}
+				}
+			}
+
+			sibling.nodeValue = value.join('');
+		}
+
+		if (!sibling.nodeValue?.length) {
+			removeNeighbor = sibling;
+		}
+
+		if (!isVoid(removed) && removed !== INVISIBLE_SPACE) {
+			charRemoved = true;
+
+			call(backspace ? Dom.after : Dom.before, sibling, fakeNode);
+
+			if (
+				mode === 'sentence' ||
+				(mode === 'word' && removed !== ' ' && removed !== NBSP_SPACE)
+			) {
+				checkRemoveChar(jodit, fakeNode, backspace, mode);
+			}
+
+			break;
+		}
+
+		let nextSibling = getSibling(sibling, backspace);
+
+		if (
+			!nextSibling &&
+			sibling.parentNode &&
+			sibling.parentNode !== jodit.editor
+		) {
+			nextSibling = findMostNestedNeighbor(
+				sibling,
+				!backspace,
+				jodit.editor,
+				true
+			);
+		}
+
+		if (removeNeighbor) {
+			Dom.safeRemove(removeNeighbor);
+			removeNeighbor = null;
+		}
+
+		sibling = nextSibling;
+	}
+
+	if (charRemoved) {
+		removeEmptyInlineParent(fakeNode);
+		addBRInsideEmptyBlock(jodit, fakeNode);
+		jodit.s.setCursorBefore(fakeNode);
+	}
+
+	return charRemoved;
+}
+
+/**
+ * Helper remove all empty inline parents
+ */
+function removeEmptyInlineParent(node: Node): void {
+	let parent = node.parentElement;
+
+	while (parent && Dom.isInlineBlock(parent)) {
+		const p = parent.parentElement;
+
+		if (Dom.isEmpty(parent)) {
+			Dom.after(parent, node);
+			Dom.safeRemove(parent);
+		}
+
+		parent = p;
+	}
+}
+
+/**
+ * Helper add BR element inside empty block element
+ */
+function addBRInsideEmptyBlock(jodit: IJodit, node: Node): void {
+	if (
+		node.parentElement !== jodit.editor &&
+		Dom.isBlock(node.parentElement) &&
+		Dom.each(node.parentElement, Dom.isEmptyTextNode)
+	) {
+		Dom.after(node, jodit.createInside.element('br'));
+	}
+}

package/src/plugins/keyboard/backspace/cases/check-remove-content-not-editable.ts

@@ -0,0 +1,46 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+import type { IJodit } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { call } from '../../../../core/helpers';
+import { normalizeCursorPosition } from '../../helpers';
+
+/**
+ * Проверяет возможность удаления не редактируемго элемента
+ */
+export function checkRemoveContentNotEditable(
+	jodit: IJodit,
+	fakeNode: Text,
+	backspace: boolean
+): boolean {
+	let neighbor = Dom.findSibling(fakeNode, backspace);
+
+	if (
+		!neighbor &&
+		fakeNode.parentElement &&
+		fakeNode.parentElement !== jodit.editor
+	) {
+		neighbor = Dom.findSibling(fakeNode.parentElement, backspace);
+	}
+
+	if (
+		Dom.isElement(neighbor) &&
+		!Dom.isContentEditable(neighbor, jodit.editor)
+	) {
+		call(backspace ? Dom.before : Dom.after, neighbor, fakeNode);
+		Dom.safeRemove(neighbor);
+		normalizeCursorPosition(jodit, fakeNode, backspace);
+
+		call(
+			backspace ? jodit.s.setCursorBefore : jodit.s.setCursorAfter,
+			fakeNode
+		);
+
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-remove-empty-neighbor.ts

@@ -0,0 +1,43 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { findNotEmptySibling } from '../../helpers';
+
+/**
+ * Check if it is possible to remove an empty adjacent element.
+ *
+ * @example
+ * ```html
+ * <p><br></p><p>|second stop</p>
+ * ```
+ * result
+ * ```html
+ * <p>|second stop</p>
+ * ```
+ */
+export function checkRemoveEmptyNeighbor(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	const parent = Dom.closest(fakeNode, Dom.isElement, jodit.editor);
+
+	if (!parent) {
+		return false;
+	}
+
+	const neighbor = findNotEmptySibling(parent, backspace);
+
+	if (neighbor && Dom.isEmpty(neighbor)) {
+		Dom.safeRemove(neighbor);
+		jodit.s.setCursorBefore(fakeNode);
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-remove-empty-parent.ts

@@ -0,0 +1,80 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit, Nullable } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { findNotEmptyNeighbor } from '../../helpers';
+import { INSEPARABLE_TAGS } from '../../../../core/constants';
+import { checkJoinTwoLists } from './check-join-two-lists';
+
+/**
+ * Check if the current empty item can be removed
+ *
+ * @example
+ * ```html
+ * <p>first stop</p><p>|<br></p>
+ * ```
+ * result
+ * ```html
+ * <p>first stop|</p>
+ * ```
+ */
+export function checkRemoveEmptyParent(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	let found: boolean = false;
+	const { setCursorBefore, setCursorIn } = jodit.s;
+
+	let prn: Nullable<Node> = Dom.closest(
+		fakeNode,
+		Dom.isElement,
+		jodit.editor
+	);
+
+	if (!prn || !Dom.isEmpty(prn)) {
+		return false;
+	}
+
+	const neighbor = findNotEmptyNeighbor(fakeNode, backspace, jodit.editor);
+
+	do {
+		if (prn && Dom.isEmpty(prn) && !Dom.isCell(prn)) {
+			Dom.after(prn, fakeNode);
+
+			const tmp: Nullable<Node> = Dom.closest(
+				prn,
+				n => Dom.isElement(n) && n !== prn,
+				jodit.editor
+			);
+
+			Dom.safeRemove(prn);
+
+			found = true;
+
+			prn = tmp;
+		} else {
+			break;
+		}
+	} while (prn);
+
+	if (found && checkJoinTwoLists(jodit, fakeNode, backspace)) {
+		return true;
+	}
+
+	if (
+		neighbor &&
+		!Dom.isText(neighbor) &&
+		!Dom.isTag(neighbor, INSEPARABLE_TAGS)
+	) {
+		setCursorIn(neighbor, !backspace);
+	} else {
+		setCursorBefore(fakeNode);
+	}
+
+	return found;
+}

package/src/plugins/keyboard/backspace/cases/check-remove-unbreakable-element.ts

@@ -0,0 +1,46 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { INSEPARABLE_TAGS } from '../../../../core/constants';
+import { checkRemoveEmptyParent } from './check-remove-empty-parent';
+
+/**
+ * Check possibility inseparable Element can be removed (img, hr etc.)
+ *
+ * @example
+ * ```html
+ * <p>first second <img>| stop</p>
+ * ```
+ * result
+ * ```html
+ * <p>first second | stop</p>
+ * ```
+ */
+export function checkRemoveUnbreakableElement(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	const neighbor = Dom.findSibling(fakeNode, backspace);
+
+	if (
+		Dom.isElement(neighbor) &&
+		(Dom.isTag(neighbor, INSEPARABLE_TAGS) || Dom.isEmpty(neighbor))
+	) {
+		Dom.safeRemove(neighbor);
+		jodit.s.setCursorBefore(fakeNode);
+
+		if (Dom.isTag(neighbor, 'br')) {
+			checkRemoveEmptyParent(jodit, fakeNode, backspace);
+		}
+
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-table-cell.ts

@@ -0,0 +1,30 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import { Dom } from '../../../../core/dom';
+import type { IJodit } from '../../../../types';
+
+/**
+ * Inside the CELL table - nothing to do
+ *
+ * @example
+ * ```html
+ * <table><tr><td>|test</td></tr></table>
+ * ```
+ * result
+ * ```html
+ * <table><tr><td>|test</td></tr></table>
+ * ```
+ */
+export function checkTableCell(jodit: IJodit, fakeNode: Node): boolean {
+	const cell = fakeNode.parentElement;
+
+	if (Dom.isCell(cell)) {
+		return true;
+	}
+
+	return false;
+}

package/src/plugins/keyboard/backspace/cases/check-unwrap-first-list-item.ts

@@ -0,0 +1,57 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2021 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+import type { IJodit } from '../../../../types';
+import { Dom } from '../../../../core/dom';
+import { call } from '../../../../core/helpers';
+
+/**
+ * For first item in list on backspace try move his content in new P
+ *
+ * @example
+ * ```html
+ * <ul><li>|first</li><li>second</li></ul>
+ * ```
+ * Result
+ * ```html
+ * <p>|first</p><ul><li>second</li></ul>
+ * ```
+ */
+export function checkUnwrapFirstListItem(
+	jodit: IJodit,
+	fakeNode: Node,
+	backspace: boolean
+): boolean {
+	const li = Dom.closest(fakeNode, Dom.isElement, jodit.editor);
+
+	const { s } = jodit;
+
+	if (
+		Dom.isTag(li, 'li') &&
+		li?.parentElement?.[
+			backspace ? 'firstElementChild' : 'lastElementChild'
+		] === li &&
+		s.cursorInTheEdge(backspace, li)
+	) {
+		const ul = li.parentElement;
+		const p = jodit.createInside.element(jodit.o.enterBlock);
+
+		call(backspace ? Dom.before : Dom.after, ul, p);
+
+		Dom.moveContent(li, p);
+		Dom.safeRemove(li);
+
+		if (Dom.isEmpty(ul)) {
+			Dom.safeRemove(ul);
+		}
+
+		call(backspace ? s.setCursorBefore : s.setCursorAfter, fakeNode);
+
+		return true;
+	}
+
+	return false;
+}