jodit 3.10.2 → 3.12.2

package/src/plugins/inline-popup/config/items/img.ts

@@ -1,7 +1,11 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/inline-popup
  */
 
 import type { IControlType, IJodit } from '../../../../types';

package/src/plugins/inline-popup/config/items/toolbar.ts

@@ -1,7 +1,11 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/inline-popup
  */
 
 export default [

package/src/plugins/inline-popup/inline-popup.less

@@ -1,7 +1,7 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 
 @import (reference) '../../styles/variables';

package/src/plugins/inline-popup/inline-popup.ts

@@ -1,7 +1,11 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/inline-popup
  */
 
 import './inline-popup.less';

package/src/plugins/insert/hr.ts

@@ -1,7 +1,11 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/insert
  */
 
 import type { IControlType, IJodit } from '../../types';

package/src/plugins/insert/index.ts

@@ -1,7 +1,11 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/insert
  */
 
 export * from './hr';

package/src/plugins/{justify.ts → justify/justify.ts}

@@ -1,13 +1,17 @@
 /*!
  * 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
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
 
-import type { IJodit, IControlType } from '../types';
-import { Config } from '../config';
-import { Dom } from '../modules/';
-import { css } from '../core/helpers/';
+/**
+ * @module plugins/justify
+ */
+
+import type { IJodit, IControlType } from '../../types';
+import { Config } from '../../config';
+import { Dom } from '../../modules/';
+import { css } from '../../core/helpers/';
 
 Config.prototype.controls.align = {
 	name: 'left',

package/src/plugins/keyboard/backspace/backspace.ts

@@ -0,0 +1,187 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2022 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+
+/**
+ * @module plugins/keyboard/backspace
+ */
+
+import { Plugin } from '../../../core/plugin';
+import type { IJodit } from '../../../types';
+import { Dom } from '../../../core/dom';
+import { INVISIBLE_SPACE } from '../../../core/constants';
+import { isFunction, trim } from '../../../core/helpers';
+import { normalizeCursorPosition } from '../helpers';
+import { cases } from './cases';
+import type { DeleteMode } from './interface';
+import { checkNotCollapsed } from './cases/check-not-collapsed';
+
+import './config';
+
+export class Backspace extends Plugin {
+	/** @override */
+	override requires = ['hotkeys'];
+
+	/** @override */
+	protected afterInit(jodit: IJodit): void {
+		jodit.e.on('afterCommand.delete', (command: 'delete' | string) => {
+			if (command === 'delete') {
+				this.afterDeleteCommand();
+			}
+		});
+
+		jodit
+			.registerCommand(
+				'deleteButton',
+				{
+					exec: () => this.onDelete(false),
+					hotkeys: jodit.o.delete.hotkeys.delete
+				},
+				{
+					stopPropagation: false
+				}
+			)
+			.registerCommand(
+				'backspaceButton',
+				{
+					exec: () => this.onDelete(true),
+					hotkeys: jodit.o.delete.hotkeys.backspace
+				},
+				{
+					stopPropagation: false
+				}
+			)
+			.registerCommand('deleteWordButton', {
+				exec: () => this.onDelete(false, 'word'),
+				hotkeys: jodit.o.delete.hotkeys.deleteWord
+			})
+			.registerCommand('backspaceWordButton', {
+				exec: () => this.onDelete(true, 'word'),
+				hotkeys: jodit.o.delete.hotkeys.backspaceWord
+			})
+			.registerCommand('deleteSentenceButton', {
+				exec: () => this.onDelete(false, 'sentence'),
+				hotkeys: jodit.o.delete.hotkeys.deleteSentence
+			})
+			.registerCommand('backspaceSentenceButton', {
+				exec: () => this.onDelete(true, 'sentence'),
+				hotkeys: jodit.o.delete.hotkeys.backspaceSentence
+			});
+	}
+
+	/** @override */
+	protected beforeDestruct(jodit: IJodit): void {
+		jodit.e.off('afterCommand.delete');
+	}
+
+	/**
+	 * After Delete command remove extra BR
+	 */
+	private afterDeleteCommand(): void {
+		const jodit = this.j;
+
+		const current = jodit.s.current();
+
+		if (current && Dom.isTag(current.firstChild, 'br')) {
+			jodit.s.removeNode(current.firstChild);
+		}
+
+		if (
+			!trim(jodit.editor.textContent || '') &&
+			!jodit.editor.querySelector('img') &&
+			(!current || !Dom.closest(current, 'table', jodit.editor))
+		) {
+			jodit.editor.innerHTML = '';
+
+			const node = jodit.s.setCursorIn(jodit.editor);
+
+			jodit.s.removeNode(node);
+		}
+	}
+
+	/**
+	 * Listener BackSpace or Delete button
+	 */
+	private onDelete(
+		backspace: boolean,
+		mode: DeleteMode = 'char'
+	): false | void {
+		const jodit = this.j;
+
+		const sel = jodit.selection;
+
+		if (!sel.isFocused()) {
+			sel.focus();
+		}
+
+		if (checkNotCollapsed(jodit)) {
+			return false;
+		}
+
+		const range = sel.range;
+		const fakeNode = jodit.createInside.text(INVISIBLE_SPACE);
+
+		try {
+			range.insertNode(fakeNode);
+
+			if (!Dom.isOrContains(jodit.editor, fakeNode)) {
+				return;
+			}
+
+			normalizeCursorPosition(jodit, fakeNode, backspace);
+
+			if (
+				cases.some(
+					(func): void | boolean =>
+						isFunction(func) &&
+						func(jodit, fakeNode, backspace, mode)
+				)
+			) {
+				return false;
+			}
+		} catch (e) {
+			if (!isProd) {
+				console.error(e);
+			}
+
+			throw e;
+		} finally {
+			this.safeRemoveEmptyNode(fakeNode);
+		}
+
+		return false;
+	}
+
+	/**
+	 * Remove node and replace cursor position out of it
+	 */
+	private safeRemoveEmptyNode(fakeNode: Node) {
+		const { range } = this.j.s;
+
+		if (range.startContainer === fakeNode) {
+			if (fakeNode.previousSibling) {
+				if (Dom.isText(fakeNode.previousSibling)) {
+					range.setStart(
+						fakeNode.previousSibling,
+						fakeNode.previousSibling.nodeValue?.length ?? 0
+					);
+				} else {
+					range.setStartAfter(fakeNode.previousSibling);
+				}
+			} else if (fakeNode.nextSibling) {
+				if (Dom.isText(fakeNode.nextSibling)) {
+					range.setStart(fakeNode.nextSibling, 0);
+				} else {
+					range.setStartBefore(fakeNode.nextSibling);
+				}
+			}
+
+			range.collapse(true);
+			this.j.s.selectRange(range);
+		}
+
+		Dom.safeRemove(fakeNode);
+	}
+}

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-2022 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,56 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2022 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>
+ * ```
+ * @private
+ */
+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,28 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2022 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>
+ * ```
+ * @private
+ */
+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,192 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2022 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
+ * ```
+ * @private
+ */
+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'));
+	}
+}