jodit 4.18.10 → 4.18.11

package/esm/plugins/backspace/cases/check-remove-content-not-editable.js

@@ -6,24 +6,52 @@
 import { Dom } from "../../../core/dom/index.js";
 import { call } from "../../../core/helpers/index.js";
 import { moveNodeInsideStart } from "../../../core/selection/helpers/index.js";
+import { checkJoinNeighbors } from "./check-join-neighbors.js";
 /**
- * Checks if a non-editable element can be deleted
+ * Checks if a non-editable element can be deleted. A non-editable block goes
+ * whole, and the lines either side of it then join, as the spec's tests do:
+ * `<ul><li>one|</li></ul><div contenteditable="false">x</div><p>two</p>`
+ * gives `<ul><li>one|two</li></ul>`
  * @private
  */
 export function checkRemoveContentNotEditable(jodit, fakeNode, backspace) {
-    let neighbor = Dom.findSibling(fakeNode, backspace);
-    if (!neighbor &&
-        fakeNode.parentElement &&
-        fakeNode.parentElement !== jodit.editor) {
-        neighbor = Dom.findSibling(fakeNode.parentElement, backspace);
+    let node = fakeNode;
+    let neighbor = Dom.findSibling(node, backspace);
+    // Past the edges of the blocks the caret is at, but not into a table cell
+    while (!neighbor &&
+        node.parentElement &&
+        node.parentElement !== jodit.editor &&
+        !Dom.isCell(node.parentElement)) {
+        node = node.parentElement;
+        neighbor = Dom.findSibling(node, backspace);
+        // At the start of a list item, Backspace takes the bullet off first,
+        // unless the item before it is a non-editable one to remove
+        if (backspace &&
+            Dom.isLeaf(node) &&
+            !(Dom.isLeaf(neighbor) && isNotEditable(jodit, neighbor))) {
+            return false;
+        }
     }
-    if (Dom.isElement(neighbor) &&
-        !Dom.isContentEditable(neighbor, jodit.editor)) {
-        call(backspace ? Dom.before : Dom.after, neighbor, fakeNode);
-        Dom.safeRemove(neighbor);
-        moveNodeInsideStart(jodit, fakeNode, backspace);
+    if (isNotEditable(jodit, neighbor)) {
+        if (Dom.isBlock(neighbor)) {
+            // Backspace after a removed list item leaves the items apart: the
+            // next press takes the bullet off, as for any later item
+            const joinLines = !(backspace && Dom.isLeaf(neighbor));
+            Dom.safeRemove(neighbor);
+            if (joinLines) {
+                checkJoinNeighbors(jodit, fakeNode, backspace);
+            }
+        }
+        else {
+            call(backspace ? Dom.before : Dom.after, neighbor, fakeNode);
+            Dom.safeRemove(neighbor);
+            moveNodeInsideStart(jodit, fakeNode, backspace);
+        }
         call(backspace ? jodit.s.setCursorBefore : jodit.s.setCursorAfter, fakeNode);
         return true;
     }
     return false;
 }
+function isNotEditable(jodit, node) {
+    return Dom.isElement(node) && !Dom.isContentEditable(node, jodit.editor);
+}

package/esm/plugins/wrap-nodes/wrap-nodes.js

@@ -13,6 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
                 r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { NO_EMPTY_TAGS } from "../../core/constants.js";
 import { autobind } from "../../core/decorators/index.js";
 import { Dom } from "../../core/dom/index.js";
 import { pluginSystem } from "../../core/global.js";
@@ -45,7 +46,9 @@ class wrapNodes extends Plugin {
          * Some element which needs to append in block
          */
         this.isNotWrapped = (n) => Dom.isElement(n) &&
-            !(Dom.isBlock(n) || Dom.isTag(n, this.j.o.wrapNodes.exclude));
+            !(Dom.isBlock(n) ||
+                Dom.isTag(n, this.j.o.wrapNodes.exclude) ||
+                holdsBlock(n));
     }
     /** @override **/
     afterInit(jodit) {
@@ -81,7 +84,9 @@ class wrapNodes extends Plugin {
                 isChanged = true;
                 const box = jodit.createInside.element(jodit.o.enter);
                 Dom.before(child, box);
-                while (child && this.isSuitable(child)) {
+                // `exclude` keeps a <br> from starting a box, but one between loose lines stays with them
+                while (child &&
+                    (this.isSuitable(child) || Dom.isTag(child, 'br'))) {
                     const next = child.nextSibling;
                     Dom.append(box, child);
                     child = next;
@@ -124,6 +129,18 @@ __decorate([
 __decorate([
     autobind
 ], wrapNodes.prototype, "preprocessInput", null);
+/**
+ * A block can't go in a paragraph, so neither can an element that holds one,
+ * such as a `<span>` round a `<p>`. Embedded content such as an `<iframe>` can.
+ */
+function holdsBlock(elm) {
+    for (const node of Dom.eachGen(elm)) {
+        if (Dom.isBlock(node) && !Dom.isTag(node, NO_EMPTY_TAGS)) {
+            return true;
+        }
+    }
+    return false;
+}
 function checkAloneListLeaf(child, jodit) {
     let result = child;
     let next = child;

package/esm/types/async.d.ts

@@ -20,6 +20,13 @@ interface RejectablePromise<T> extends Promise<T> {
 }
 export interface IAsync extends IDestructible {
     delay(timeout: number | IAsyncParams): Promise<void>;
+    /**
+     * Calls `callback` after `timeout` milliseconds, unless the view is
+     * destroyed first. A timeout of 0, or none, calls it at once, before
+     * returning, where `window.setTimeout(callback, 0)` would wait for the
+     * current event to finish. To run after the browser has handled an event,
+     * such as moving the caret on a keydown, use a timeout of at least 1.
+     */
     setTimeout<T = any>(callback: (...args: T[]) => void, timeout: number | IAsyncParams, ...args: T[]): number;
     updateTimeout(label: string, timeout: number): Nullable<number>;
     clearTimeout(timer: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jodit",
-	"version": "4.18.10",
+	"version": "4.18.11",
 	"description": "Jodit is an awesome and useful wysiwyg editor with filebrowser",
 	"main": "esm/index.js",
 	"types": "types/index.d.ts",

package/types/core/helpers/size/get-fixed-position-offset.d.ts

@@ -15,7 +15,9 @@ import type { IPoint } from "../../../types/index";
  * ancestor's top-left corner. The returned offset should be subtracted from
  * the desired viewport coordinates before applying them.
  *
- * Returns `{ x: 0, y: 0 }` when no such ancestor exists (the common case), so
- * call sites keep their previous behaviour unchanged.
+ * Without such an ancestor the containing block is the layout viewport. Its
+ * offset is `{ x: 0, y: 0 }` in most browsers, but WebKit measures client
+ * rects from the visual viewport, so once the page is pinch-zoomed and panned
+ * the layout viewport starts above and to the left of the client origin.
  */
 export declare function getFixedPositionOffset(elm: HTMLElement): IPoint;

package/types/plugins/add-new-line/add-new-line.d.ts

@@ -30,6 +30,13 @@ export declare class addNewLine extends Plugin {
     protected afterInit(editor: IJodit): void;
     private __addEventListeners;
     private __onClickLine;
+    /**
+     * A paragraph holding only an embed has no place for the caret, so the
+     * arrow keys can't get past one that ends the content, or before one that
+     * starts it. When an arrow key leaves the caret where it was and there is
+     * content beyond it, a new line goes there, as when the line is clicked.
+     */
+    protected onArrowKey(e: KeyboardEvent): void;
     protected onDblClickEditor(e: MouseEvent): void;
     private __onMouseMove;
     /** @override */

package/types/plugins/backspace/backspace.d.ts

@@ -19,6 +19,13 @@ export declare class backspace extends Plugin {
      * Listener BackSpace or Delete button
      */
     private onDelete;
+    /**
+     * The browser types at the end of the text before the caret on its line,
+     * in that text's formatting, but not inside a link. Moving the caret there
+     * too makes a paste and the toolbar agree with what's typed:
+     * `<p>one</p><p><b>|two</b></p>` joins to `<p>one|<b>two</b></p>`
+     */
+    private moveCaretToTextBefore;
     /**
      * Remove node and replace cursor position out of it
      */

package/types/plugins/backspace/cases/check-remove-content-not-editable.d.ts

@@ -8,7 +8,10 @@
  */
 import type { IJodit } from "../../../types/index";
 /**
- * Checks if a non-editable element can be deleted
+ * Checks if a non-editable element can be deleted. A non-editable block goes
+ * whole, and the lines either side of it then join, as the spec's tests do:
+ * `<ul><li>one|</li></ul><div contenteditable="false">x</div><p>two</p>`
+ * gives `<ul><li>one|two</li></ul>`
  * @private
  */
 export declare function checkRemoveContentNotEditable(jodit: IJodit, fakeNode: Text, backspace: boolean): boolean;

package/types/types/async.d.ts

@@ -20,6 +20,13 @@ interface RejectablePromise<T> extends Promise<T> {
 }
 export interface IAsync extends IDestructible {
     delay(timeout: number | IAsyncParams): Promise<void>;
+    /**
+     * Calls `callback` after `timeout` milliseconds, unless the view is
+     * destroyed first. A timeout of 0, or none, calls it at once, before
+     * returning, where `window.setTimeout(callback, 0)` would wait for the
+     * current event to finish. To run after the browser has handled an event,
+     * such as moving the caret on a keydown, use a timeout of at least 1.
+     */
     setTimeout<T = any>(callback: (...args: T[]) => void, timeout: number | IAsyncParams, ...args: T[]): number;
     updateTimeout(label: string, timeout: number): Nullable<number>;
     clearTimeout(timer: number): void;