jodit 4.12.43 → 4.13.3

package/es2021/jodit.js

@@ -1,7 +1,7 @@
 /*!
  * jodit - Jodit is an awesome and useful wysiwyg editor with filebrowser
  * Author: Chupurnov <chupurnov@gmail.com> (https://xdsoft.net/jodit/)
- * Version: v4.12.43
+ * Version: v4.13.3
  * Url: https://xdsoft.net/jodit/
  * License(s): MIT
  */
@@ -378,6 +378,26 @@ let ConfigPrototype = {};
         /**
 	 * if set true, then the current mode is saved in a cookie, and is restored after a reload of the page
 	 */ (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "saveModeInStorage", false);
+        /**
+	 * Configure the provider that backs {@link IViewBased.asyncStorage}.
+	 *
+	 * By default the editor's `asyncStorage` uses persistent `IndexedDB` (with an
+	 * in-memory fallback when it is unavailable). Set `defaultProvider` to override it:
+	 * - `'local'` — persist in `localStorage`;
+	 * - `'memory'` — keep everything in memory (nothing survives a reload);
+	 * - a custom {@link IAsyncStorage} implementation — plug in your own backend.
+	 *
+	 * ```javascript
+	 * Jodit.make('#editor', {
+	 *    asyncStorage: { defaultProvider: 'local' }
+	 * });
+	 *
+	 * // or a fully custom backend
+	 * Jodit.make('#editor', {
+	 *    asyncStorage: { defaultProvider: myAsyncStorage }
+	 * });
+	 * ```
+	 */ (0,_swc_helpers_define_property__WEBPACK_IMPORTED_MODULE_0__._)(this, "asyncStorage", {});
         /**
 	 * Class name that can be appended to the editable area
 	 *
@@ -1823,7 +1843,7 @@ __webpack_require__.r(__webpack_exports__);
  * ```
  * @packageDocumentation
  * @module constants
- */ const APP_VERSION = "4.12.43";
+ */ const APP_VERSION = "4.13.3";
 // prettier-ignore
 const ES = "es2021";
 const IS_ES_MODERN = true;
@@ -11286,6 +11306,128 @@ class Selection {
         }
         return '';
     }
+    /**
+	 * Splits the boundaries of the current selection and wraps every
+	 * contiguous run of selected inline content (grouped by block) into a
+	 * `<font>` element, returning those wrappers in document order.
+	 *
+	 * This is a pure-DOM replacement for the old
+	 * `nativeExecCommand('fontsize', false, '7')` trick which relied on the
+	 * browser to split the selection into `<font size="7">` fragments.
+	 */ __wrapSelectionFragments() {
+        const range = this.range;
+        this.__splitSelectionBoundaries(range);
+        let root = range.commonAncestorContainer;
+        if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isText(root)) {
+            root = root.parentNode;
+        }
+        if (!root) {
+            return [];
+        }
+        return this.__wrapSelectionRuns(this.__collectContainedNodes(root, range));
+    }
+    /**
+	 * Splits the text nodes at both ends of the range so that its boundaries
+	 * always fall between nodes. Afterwards every node inside the range is
+	 * fully (not partially) selected.
+	 */ __splitSelectionBoundaries(range) {
+        let { startContainer, endContainer } = range;
+        let { startOffset, endOffset } = range;
+        if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isText(endContainer) && endOffset > 0 && endOffset < (endContainer.nodeValue?.length ?? 0)) {
+            endContainer.splitText(endOffset);
+            endOffset = endContainer.nodeValue?.length ?? endOffset;
+        }
+        if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isText(startContainer) && startOffset > 0 && startOffset < (startContainer.nodeValue?.length ?? 0)) {
+            const middle = startContainer.splitText(startOffset);
+            // Selection located inside a single text node - the tail we just
+            // cut off is the actual selected fragment.
+            if (startContainer === endContainer) {
+                endContainer = middle;
+                endOffset = middle.nodeValue?.length ?? 0;
+            }
+            startContainer = middle;
+            startOffset = 0;
+        }
+        range.setStart(startContainer, startOffset);
+        range.setEnd(endContainer, endOffset);
+        // Normalize text-edge boundaries (e.g. `(text, 0)` or `(text, length)`)
+        // to the element level so that containment checks based on
+        // `selectNode()` treat a fully selected text node as contained.
+        this.__normalizeRangeBoundary(range, true);
+        this.__normalizeRangeBoundary(range, false);
+    }
+    __normalizeRangeBoundary(range, atStart) {
+        const container = atStart ? range.startContainer : range.endContainer;
+        if (!jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isText(container)) {
+            return;
+        }
+        const offset = atStart ? range.startOffset : range.endOffset;
+        const length = container.nodeValue?.length ?? 0;
+        if (offset === 0) {
+            atStart ? range.setStartBefore(container) : range.setEndBefore(container);
+        } else if (offset >= length) {
+            atStart ? range.setStartAfter(container) : range.setEndAfter(container);
+        }
+    }
+    /**
+	 * Collects the highest-level nodes that are completely inside the range,
+	 * descending into nodes that are only partially selected.
+	 */ __collectContainedNodes(root, range) {
+        const result = [];
+        (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.toArray)(root.childNodes).forEach((child)=>{
+            if (this.__isFullyContained(range, child)) {
+                result.push(child);
+            } else if (child.childNodes.length && range.intersectsNode(child)) {
+                result.push(...this.__collectContainedNodes(child, range));
+            }
+        });
+        return result;
+    }
+    __isFullyContained(range, node) {
+        const nodeRange = this.createRange();
+        nodeRange.selectNode(node);
+        return range.compareBoundaryPoints(Range.START_TO_START, nodeRange) <= 0 && range.compareBoundaryPoints(Range.END_TO_END, nodeRange) >= 0;
+    }
+    /**
+	 * Wraps every contiguous run of selected inline siblings into a `<font>`
+	 * element. Block-level nodes are never wrapped themselves - their inline
+	 * content is wrapped instead, keeping every `<font>` inside a single block.
+	 */ __wrapSelectionRuns(nodes) {
+        const fonts = [];
+        let run = [];
+        const flush = ()=>{
+            if (run.length) {
+                fonts.push(this.__wrapRunInFont(run));
+                run = [];
+            }
+        };
+        nodes.forEach((node)=>{
+            if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isElement(node) && this.__isOrContainsBlock(node)) {
+                flush();
+                fonts.push(...this.__wrapSelectionRuns((0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.toArray)(node.childNodes)));
+            } else {
+                if (run.length && run[run.length - 1].parentNode !== node.parentNode) {
+                    flush();
+                }
+                run.push(node);
+            }
+        });
+        flush();
+        return fonts;
+    }
+    __isOrContainsBlock(node) {
+        if (jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.isBlock(node)) {
+            return true;
+        }
+        return (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.toArray)(node.childNodes).some((child)=>this.__isOrContainsBlock(child));
+    }
+    __wrapRunInFont(run) {
+        const font = this.j.createInside.element('font');
+        const [first] = run;
+        first.parentNode?.insertBefore(font, first);
+        run.forEach((node)=>font.appendChild(node));
+        return font;
+    }
     /**
 	 * Wrap all selected fragments inside Tag or apply some callback
 	 */ *wrapInTagGen(fakes) {
@@ -11299,20 +11441,7 @@ class Selection {
             jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_4__.Dom.unwrap(font);
             return;
         }
-        // fix issue https://github.com/xdan/jodit/issues/65
-        (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.$$)('*[style*=font-size]', this.area).forEach((elm)=>{
-            (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.attr)(elm, 'data-font-size', elm.style.fontSize.toString());
-            elm.style.removeProperty('font-size');
-        });
-        this.j.nativeExecCommand('fontsize', false, '7');
-        (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.$$)('*[data-font-size]', this.area).forEach((elm)=>{
-            const fontSize = (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.attr)(elm, 'data-font-size');
-            if (fontSize) {
-                elm.style.fontSize = fontSize;
-                (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.attr)(elm, 'data-font-size', null);
-            }
-        });
-        const elms = (0,jodit_core_helpers__WEBPACK_IMPORTED_MODULE_5__.$$)('font[size="7"]', this.area);
+        const elms = this.__wrapSelectionFragments();
         for (const font of elms){
             const { firstChild, lastChild } = font;
             if (firstChild && firstChild === lastChild && (0,jodit_core_helpers_checker__WEBPACK_IMPORTED_MODULE_6__.isMarker)(firstChild)) {
@@ -13031,9 +13160,23 @@ class AsyncStorage {
             await provider.close();
         }
     }
-    static makeStorage(persistentOrStrategy = false, suffix) {
+    static makeStorage(persistentOrStrategy = false, suffix, options) {
         let provider = undefined;
         let storage = null;
+        // An explicit `defaultProvider` overrides the strategy-based selection
+        // below and decides which provider backs the storage.
+        const defaultProvider = options?.defaultProvider;
+        if (defaultProvider != null) {
+            if (defaultProvider === 'local') {
+                provider = (0,_engines_local_storage_provider__WEBPACK_IMPORTED_MODULE_3__.canUsePersistentStorage)('localStorage') ? new _engines_local_storage_provider__WEBPACK_IMPORTED_MODULE_3__.LocalStorageProvider(_storage__WEBPACK_IMPORTED_MODULE_5__.StorageKey + (suffix || '')) : new _engines_memory_storage_provider__WEBPACK_IMPORTED_MODULE_4__.MemoryStorageProvider();
+            } else if (defaultProvider === 'memory') {
+                provider = new _engines_memory_storage_provider__WEBPACK_IMPORTED_MODULE_4__.MemoryStorageProvider();
+            } else {
+                // A custom IAsyncStorage implementation, used as-is.
+                provider = defaultProvider;
+            }
+            return new AsyncStorage(Promise.resolve(provider), suffix);
+        }
         if (persistentOrStrategy === 'localStorage' || persistentOrStrategy === 'sessionStorage') {
             if ((0,_engines_local_storage_provider__WEBPACK_IMPORTED_MODULE_3__.canUsePersistentStorage)(persistentOrStrategy)) {
                 provider = new _engines_local_storage_provider__WEBPACK_IMPORTED_MODULE_3__.LocalStorageProvider(_storage__WEBPACK_IMPORTED_MODULE_5__.StorageKey + (suffix || ''), persistentOrStrategy);
@@ -13321,7 +13464,12 @@ function clearUseIndexedDBCache() {
     }
     delete(key) {
         try {
-            this.storage.removeItem(this.rootKey);
+            const buffer = this.storage.getItem(this.rootKey);
+            if (buffer) {
+                const json = JSON.parse(buffer);
+                delete json[key];
+                this.storage.setItem(this.rootKey, JSON.stringify(json));
+            }
         } catch  {}
         return this;
     }
@@ -16489,9 +16637,23 @@ class ViewWithToolbar extends jodit_core_view_view__WEBPACK_IMPORTED_MODULE_11__
         if (!this.o.fullsize && ((0,jodit_core_helpers_checker_is_string__WEBPACK_IMPORTED_MODULE_7__.isString)(this.o.toolbar) || jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_5__.Dom.isHTMLElement(this.o.toolbar))) {
             return (0,jodit_core_helpers_utils_selector__WEBPACK_IMPORTED_MODULE_8__.resolveElement)(this.o.toolbar, this.o.shadowRoot || this.od);
         }
-        this.o.toolbar && jodit_core_dom_dom__WEBPACK_IMPORTED_MODULE_5__.Dom.appendChildFirst(this.container, this.__defaultToolbarContainer);
+        this.o.toolbar && this.__appendToolbarBox();
         return this.__defaultToolbarContainer;
     }
+    /**
+	 * Keep the toolbar box as the first child of the container, except that
+	 * children flagged with `data-jodit-above-toolbar` (e.g. the `above`
+	 * workplace slot used for presence bars and banners) stay above it.
+	 */ __appendToolbarBox() {
+        const box = this.__defaultToolbarContainer;
+        let anchor = this.container.firstElementChild;
+        while(anchor && anchor !== box && anchor.hasAttribute('data-jodit-above-toolbar')){
+            anchor = anchor.nextElementSibling;
+        }
+        if (anchor !== box) {
+            this.container.insertBefore(box, anchor);
+        }
+    }
     /**
 	 * Change panel container
 	 */ setPanel(element) {
@@ -16686,7 +16848,7 @@ class View extends jodit_core_component_component__WEBPACK_IMPORTED_MODULE_3__.C
     /**
 	 * Container for persistent set/get value
 	 */ get asyncStorage() {
-        return jodit_core_storage_async_storage__WEBPACK_IMPORTED_MODULE_14__.AsyncStorage.makeStorage(true, this.id);
+        return jodit_core_storage_async_storage__WEBPACK_IMPORTED_MODULE_14__.AsyncStorage.makeStorage(true, this.id, this.o.asyncStorage);
     }
     /**
 	 * Short alias for `create`
@@ -17765,6 +17927,12 @@ class Jodit extends jodit_modules__WEBPACK_IMPORTED_MODULE_9__.ViewWithToolbar {
             element.style.display = 'none';
         }
         const SLOT = 'workplace-slot';
+        // A slot that always stays ABOVE the toolbar (presence bars, banners…).
+        // The `data-jodit-above-toolbar` attribute tells ViewWithToolbar to keep
+        // the toolbar box below it when (re)attaching the toolbar container.
+        const aboveSlot = this.c.div(this.getFullElName(SLOT, 'above'), NOEDIT);
+        aboveSlot.setAttribute('data-jodit-above-toolbar', '');
+        jodit_modules__WEBPACK_IMPORTED_MODULE_9__.Dom.appendChildFirst(container, aboveSlot);
         const topSlot = this.c.div(this.getFullElName(SLOT, 'top'), NOEDIT);
         container.appendChild(topSlot);
         const centerSlot = this.c.div(this.getFullElName(SLOT, 'center'), NOEDIT);
@@ -17797,6 +17965,7 @@ class Jodit extends jodit_modules__WEBPACK_IMPORTED_MODULE_9__.ViewWithToolbar {
             container,
             workplace,
             slots: {
+                above: aboveSlot,
                 top: topSlot,
                 bottom: bottomPanel,
                 center: centerSlot,