@lexical/mark 0.12.2 → 0.12.4

package/LexicalMark.dev.js

@@ -16,22 +16,19 @@ var utils = require('@lexical/utils');
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 /** @noInheritDoc */
 class MarkNode extends lexical.ElementNode {
   /** @internal */
+
   static getType() {
     return 'mark';
   }
-
   static clone(node) {
     return new MarkNode(Array.from(node.__ids), node.__key);
   }
-
   static importDOM() {
     return null;
   }
-
   static importJSON(serializedNode) {
     const node = $createMarkNode(serializedNode.ids);
     node.setFormat(serializedNode.format);
@@ -39,38 +36,32 @@ class MarkNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
-
   exportJSON() {
-    return { ...super.exportJSON(),
+    return {
+      ...super.exportJSON(),
       ids: this.getIDs(),
       type: 'mark',
       version: 1
     };
   }
-
   constructor(ids, key) {
     super(key);
     this.__ids = ids || [];
   }
-
   createDOM(config) {
     const element = document.createElement('mark');
     utils.addClassNamesToElement(element, config.theme.mark);
-
     if (this.__ids.length > 1) {
       utils.addClassNamesToElement(element, config.theme.markOverlap);
     }
-
     return element;
   }
-
   updateDOM(prevNode, element, config) {
     const prevIDs = prevNode.__ids;
     const nextIDs = this.__ids;
     const prevIDsCount = prevIDs.length;
     const nextIDsCount = nextIDs.length;
     const overlapTheme = config.theme.markOverlap;
-
     if (prevIDsCount !== nextIDsCount) {
       if (prevIDsCount === 1) {
         if (nextIDsCount === 2) {
@@ -80,50 +71,38 @@ class MarkNode extends lexical.ElementNode {
         utils.removeClassNamesFromElement(element, overlapTheme);
       }
     }
-
     return false;
   }
-
   hasID(id) {
     const ids = this.getIDs();
-
     for (let i = 0; i < ids.length; i++) {
       if (id === ids[i]) {
         return true;
       }
     }
-
     return false;
   }
-
   getIDs() {
     const self = this.getLatest();
     return $isMarkNode(self) ? self.__ids : [];
   }
-
   addID(id) {
     const self = this.getWritable();
-
     if ($isMarkNode(self)) {
       const ids = self.__ids;
       self.__ids = ids;
-
       for (let i = 0; i < ids.length; i++) {
         // If we already have it, don't add again
         if (id === ids[i]) return;
       }
-
       ids.push(id);
     }
   }
-
   deleteID(id) {
     const self = this.getWritable();
-
     if ($isMarkNode(self)) {
       const ids = self.__ids;
       self.__ids = ids;
-
       for (let i = 0; i < ids.length; i++) {
         if (id === ids[i]) {
           ids.splice(i, 1);
@@ -132,40 +111,31 @@ class MarkNode extends lexical.ElementNode {
       }
     }
   }
-
   insertNewAfter(selection, restoreSelection = true) {
     const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
-
     if (lexical.$isElementNode(element)) {
       const markNode = $createMarkNode(this.__ids);
       element.append(markNode);
       return markNode;
     }
-
     return null;
   }
-
   canInsertTextBefore() {
     return false;
   }
-
   canInsertTextAfter() {
     return false;
   }
-
   canBeEmpty() {
     return false;
   }
-
   isInline() {
     return true;
   }
-
   extractWithChild(child, selection, destination) {
     if (!lexical.$isRangeSelection(selection) || destination === 'html') {
       return false;
     }
-
     const anchor = selection.anchor;
     const focus = selection.focus;
     const anchorNode = anchor.getNode();
@@ -174,11 +144,9 @@ class MarkNode extends lexical.ElementNode {
     const selectionLength = isBackward ? anchor.offset - focus.offset : focus.offset - anchor.offset;
     return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selectionLength;
   }
-
   excludeFromCopy(destination) {
     return destination !== 'clone';
   }
-
 }
 function $createMarkNode(ids) {
   return lexical.$applyNodeReplacement(new MarkNode(ids));
@@ -191,19 +159,15 @@ function $isMarkNode(node) {
 function $unwrapMarkNode(node) {
   const children = node.getChildren();
   let target = null;
-
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
-
     if (target === null) {
       node.insertBefore(child);
     } else {
       target.insertAfter(child);
     }
-
     target = child;
   }
-
   node.remove();
 }
 function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
@@ -214,33 +178,29 @@ function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
   const startOffset = isBackward ? focusOffset : anchorOffset;
   const endOffset = isBackward ? anchorOffset : focusOffset;
   let currentNodeParent;
-  let lastCreatedMarkNode; // We only want wrap adjacent text nodes, line break nodes
+  let lastCreatedMarkNode;
+
+  // We only want wrap adjacent text nodes, line break nodes
   // and inline element nodes. For decorator nodes and block
   // element nodes, we step out of their boundary and start
   // again after, if there are more nodes.
-
   for (let i = 0; i < nodesLength; i++) {
     const node = nodes[i];
-
     if (lexical.$isElementNode(lastCreatedMarkNode) && lastCreatedMarkNode.isParentOf(node)) {
       // If the current node is a child of the last created mark node, there is nothing to do here
       continue;
     }
-
     const isFirstNode = i === 0;
     const isLastNode = i === nodesLength - 1;
     let targetNode = null;
-
     if (lexical.$isTextNode(node)) {
       // Case 1: The node is a text node and we can split it
       const textContentSize = node.getTextContentSize();
       const startTextOffset = isFirstNode ? startOffset : 0;
       const endTextOffset = isLastNode ? endOffset : textContentSize;
-
       if (startTextOffset === 0 && endTextOffset === 0) {
         continue;
       }
-
       const splitNodes = node.splitText(startTextOffset, endTextOffset);
       targetNode = splitNodes.length > 1 && (splitNodes.length === 3 || isFirstNode && !isLastNode || endTextOffset === textContentSize) ? splitNodes[1] : splitNodes[0];
     } else if ($isMarkNode(node)) {
@@ -249,13 +209,13 @@ function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
       // another mark, it may utlimately be unnested by a call to
       // `registerNestedElementResolver<MarkNode>` somewhere else in the
       // codebase.
+
       continue;
     } else if (lexical.$isElementNode(node) && node.isInline()) {
       // Case 3: inline element nodes can be added in their entirety to the new
       // mark
       targetNode = node;
     }
-
     if (targetNode !== null) {
       // Now that we have a target node for wrapping with a mark, we can run
       // through special cases.
@@ -264,25 +224,21 @@ function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
         // is nothing to do here.
         continue;
       }
-
       const parentNode = targetNode.getParent();
-
       if (parentNode == null || !parentNode.is(currentNodeParent)) {
         // If the parent node is not the current node's parent node, we can
         // clear the last created mark node.
         lastCreatedMarkNode = undefined;
       }
-
       currentNodeParent = parentNode;
-
       if (lastCreatedMarkNode === undefined) {
         // If we don't have a created mark node, we can make one
         const createMarkNode = createNode || $createMarkNode;
         lastCreatedMarkNode = createMarkNode([id]);
         targetNode.insertBefore(lastCreatedMarkNode);
-      } // Add the target node to be wrapped in the latest created mark node
-
+      }
 
+      // Add the target node to be wrapped in the latest created mark node
       lastCreatedMarkNode.append(targetNode);
     } else {
       // If we don't have a target node to wrap we can clear our state and
@@ -290,9 +246,8 @@ function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
       currentNodeParent = undefined;
       lastCreatedMarkNode = undefined;
     }
-  } // Make selection collapsed at the end
-
-
+  }
+  // Make selection collapsed at the end
   if (lexical.$isElementNode(lastCreatedMarkNode)) {
     // eslint-disable-next-line no-unused-expressions
     isBackward ? lastCreatedMarkNode.selectStart() : lastCreatedMarkNode.selectEnd();
@@ -300,21 +255,17 @@ function $wrapSelectionInMarkNode(selection, isBackward, id, createNode) {
 }
 function $getMarkIDs(node, offset) {
   let currentNode = node;
-
   while (currentNode !== null) {
     if ($isMarkNode(currentNode)) {
       return currentNode.getIDs();
     } else if (lexical.$isTextNode(currentNode) && offset === currentNode.getTextContentSize()) {
       const nextSibling = currentNode.getNextSibling();
-
       if ($isMarkNode(nextSibling)) {
         return nextSibling.getIDs();
       }
     }
-
     currentNode = currentNode.getParent();
   }
-
   return null;
 }
 

package/package.json

@@ -8,13 +8,13 @@
     "mark"
   ],
   "license": "MIT",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "main": "LexicalMark.js",
   "peerDependencies": {
-    "lexical": "0.12.2"
+    "lexical": "0.12.4"
   },
   "dependencies": {
-    "@lexical/utils": "0.12.2"
+    "@lexical/utils": "0.12.4"
   },
   "repository": {
     "type": "git",