@lexical/react 0.7.7 → 0.7.9

package/DEPRECATED_useLexical.dev.js

@@ -18,6 +18,7 @@ var utils = require('@lexical/utils');
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -37,12 +38,10 @@ var useLayoutEffect = useLayoutEffectImpl;
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function canShowPlaceholderFromCurrentEditorState(editor) {
   const currentCanShowPlaceholder = editor.getEditorState().read(text.$canShowPlaceholderCurry(editor.isComposing()));
   return currentCanShowPlaceholder;
 }
-
 function useCanShowPlaceholder(editor) {
   const [canShowPlaceholder, setCanShowPlaceholder] = react.useState(() => canShowPlaceholderFromCurrentEditorState(editor));
   useLayoutEffect(() => {
@@ -50,7 +49,6 @@ function useCanShowPlaceholder(editor) {
       const currentCanShowPlaceholder = canShowPlaceholderFromCurrentEditorState(editor);
       setCanShowPlaceholder(currentCanShowPlaceholder);
     }
-
     resetCanShowPlaceholder();
     return utils.mergeRegister(editor.registerUpdateListener(() => {
       resetCanShowPlaceholder();
@@ -95,7 +93,8 @@ function useLexicalEditor(editor) {
  *
  */
 function useLexical(editorConfig) {
-  const editor = react.useMemo(() => lexical.createEditor(editorConfig), // Init
+  const editor = react.useMemo(() => lexical.createEditor(editorConfig),
+  // Init
   // eslint-disable-next-line react-hooks/exhaustive-deps
   []);
   const [rootElementRef, showPlaceholder] = useLexicalEditor(editor);

package/DEPRECATED_useLexicalCanShowPlaceholder.dev.js

@@ -17,6 +17,7 @@ var react = require('react');
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -36,12 +37,10 @@ var useLayoutEffect = useLayoutEffectImpl;
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function canShowPlaceholderFromCurrentEditorState(editor) {
   const currentCanShowPlaceholder = editor.getEditorState().read(text.$canShowPlaceholderCurry(editor.isComposing()));
   return currentCanShowPlaceholder;
 }
-
 function useCanShowPlaceholder(editor) {
   const [canShowPlaceholder, setCanShowPlaceholder] = react.useState(() => canShowPlaceholderFromCurrentEditorState(editor));
   useLayoutEffect(() => {
@@ -49,7 +48,6 @@ function useCanShowPlaceholder(editor) {
       const currentCanShowPlaceholder = canShowPlaceholderFromCurrentEditorState(editor);
       setCanShowPlaceholder(currentCanShowPlaceholder);
     }
-
     resetCanShowPlaceholder();
     return utils.mergeRegister(editor.registerUpdateListener(() => {
       resetCanShowPlaceholder();

package/DEPRECATED_useLexicalCharacterLimit.dev.js

@@ -44,16 +44,13 @@ function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({}))
     }) => {
       const isComposing = editor.isComposing();
       const hasDirtyLeaves = dirtyLeaves.size > 0;
-
       if (isComposing || !hasDirtyLeaves) {
         return;
       }
-
       const textLength = strlen(text$1);
       const textLengthAboveThreshold = textLength > maxCharacters || lastComputedTextLength !== null && lastComputedTextLength > maxCharacters;
       const diff = maxCharacters - textLength;
       remainingCharacters(diff);
-
       if (lastComputedTextLength === null || textLengthAboveThreshold) {
         const offset = findOffset(text$1, maxCharacters, strlen);
         editor.update(() => {
@@ -62,75 +59,62 @@ function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({}))
           tag: 'history-merge'
         });
       }
-
       lastComputedTextLength = textLength;
     }));
   }, [editor, maxCharacters, remainingCharacters, strlen]);
 }
-
 function findOffset(text, maxCharacters, strlen) {
   // @ts-ignore This is due to be added in a later version of TS
   const Segmenter = Intl.Segmenter;
   let offsetUtf16 = 0;
   let offset = 0;
-
   if (typeof Segmenter === 'function') {
     const segmenter = new Segmenter();
     const graphemes = segmenter.segment(text);
-
     for (const {
       segment: grapheme
     } of graphemes) {
       const nextOffset = offset + strlen(grapheme);
-
       if (nextOffset > maxCharacters) {
         break;
       }
-
       offset = nextOffset;
       offsetUtf16 += grapheme.length;
     }
   } else {
     const codepoints = Array.from(text);
     const codepointsLength = codepoints.length;
-
     for (let i = 0; i < codepointsLength; i++) {
       const codepoint = codepoints[i];
       const nextOffset = offset + strlen(codepoint);
-
       if (nextOffset > maxCharacters) {
         break;
       }
-
       offset = nextOffset;
       offsetUtf16 += codepoint.length;
     }
   }
-
   return offsetUtf16;
 }
-
 function $wrapOverflowedNodes(offset) {
   const dfsNodes = utils.$dfs();
   const dfsNodesLength = dfsNodes.length;
   let accumulatedLength = 0;
-
   for (let i = 0; i < dfsNodesLength; i += 1) {
     const {
       node
     } = dfsNodes[i];
-
     if (overflow.$isOverflowNode(node)) {
       const previousLength = accumulatedLength;
       const nextLength = accumulatedLength + node.getTextContentSize();
-
       if (nextLength <= offset) {
         const parent = node.getParent();
         const previousSibling = node.getPreviousSibling();
         const nextSibling = node.getNextSibling();
         $unwrapNode(node);
-        const selection = lexical.$getSelection(); // Restore selection when the overflow children are removed
+        const selection = lexical.$getSelection();
 
+        // Restore selection when the overflow children are removed
         if (lexical.$isRangeSelection(selection) && (!selection.anchor.getNode().isAttached() || !selection.focus.getNode().isAttached())) {
           if (lexical.$isTextNode(previousSibling)) {
             previousSibling.select();
@@ -143,12 +127,11 @@ function $wrapOverflowedNodes(offset) {
       } else if (previousLength < offset) {
         const descendant = node.getFirstDescendant();
         const descendantLength = descendant !== null ? descendant.getTextContentSize() : 0;
-        const previousPlusDescendantLength = previousLength + descendantLength; // For simple text we can redimension the overflow into a smaller and more accurate
+        const previousPlusDescendantLength = previousLength + descendantLength;
+        // For simple text we can redimension the overflow into a smaller and more accurate
         // container
-
         const firstDescendantIsSimpleText = lexical.$isTextNode(descendant) && descendant.isSimpleText();
         const firstDescendantDoesNotOverflow = previousPlusDescendantLength <= offset;
-
         if (firstDescendantIsSimpleText || firstDescendantDoesNotOverflow) {
           $unwrapNode(node);
         }
@@ -156,59 +139,49 @@ function $wrapOverflowedNodes(offset) {
     } else if (lexical.$isLeafNode(node)) {
       const previousAccumulatedLength = accumulatedLength;
       accumulatedLength += node.getTextContentSize();
-
       if (accumulatedLength > offset && !overflow.$isOverflowNode(node.getParent())) {
         const previousSelection = lexical.$getSelection();
-        let overflowNode; // For simple text we can improve the limit accuracy by splitting the TextNode
-        // on the split point
+        let overflowNode;
 
+        // For simple text we can improve the limit accuracy by splitting the TextNode
+        // on the split point
         if (previousAccumulatedLength < offset && lexical.$isTextNode(node) && node.isSimpleText()) {
           const [, overflowedText] = node.splitText(offset - previousAccumulatedLength);
           overflowNode = $wrapNode(overflowedText);
         } else {
           overflowNode = $wrapNode(node);
         }
-
         if (previousSelection !== null) {
           lexical.$setSelection(previousSelection);
         }
-
         mergePrevious(overflowNode);
       }
     }
   }
 }
-
 function $wrapNode(node) {
   const overflowNode = overflow.$createOverflowNode();
   node.insertBefore(overflowNode);
   overflowNode.append(node);
   return overflowNode;
 }
-
 function $unwrapNode(node) {
   const children = node.getChildren();
   const childrenLength = children.length;
-
   for (let i = 0; i < childrenLength; i++) {
     node.insertBefore(children[i]);
   }
-
   node.remove();
   return childrenLength > 0 ? children[childrenLength - 1] : null;
 }
-
 function mergePrevious(overflowNode) {
   const previousNode = overflowNode.getPreviousSibling();
-
   if (!overflow.$isOverflowNode(previousNode)) {
     return;
   }
-
   const firstChild = overflowNode.getFirstChild();
   const previousNodeChildren = previousNode.getChildren();
   const previousNodeChildrenLength = previousNodeChildren.length;
-
   if (firstChild === null) {
     overflowNode.append(...previousNodeChildren);
   } else {
@@ -216,28 +189,23 @@ function mergePrevious(overflowNode) {
       firstChild.insertBefore(previousNodeChildren[i]);
     }
   }
-
   const selection = lexical.$getSelection();
-
   if (lexical.$isRangeSelection(selection)) {
     const anchor = selection.anchor;
     const anchorNode = anchor.getNode();
     const focus = selection.focus;
     const focusNode = anchor.getNode();
-
     if (anchorNode.is(previousNode)) {
       anchor.set(overflowNode.getKey(), anchor.offset, 'element');
     } else if (anchorNode.is(overflowNode)) {
       anchor.set(overflowNode.getKey(), previousNodeChildrenLength + anchor.offset, 'element');
     }
-
     if (focusNode.is(previousNode)) {
       focus.set(overflowNode.getKey(), focus.offset, 'element');
     } else if (focusNode.is(overflowNode)) {
       focus.set(overflowNode.getKey(), previousNodeChildrenLength + focus.offset, 'element');
     }
   }
-
   previousNode.remove();
 }
 

package/DEPRECATED_useLexicalEditor.dev.js

@@ -17,6 +17,7 @@ var utils = require('@lexical/utils');
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -36,12 +37,10 @@ var useLayoutEffect = useLayoutEffectImpl;
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function canShowPlaceholderFromCurrentEditorState(editor) {
   const currentCanShowPlaceholder = editor.getEditorState().read(text.$canShowPlaceholderCurry(editor.isComposing()));
   return currentCanShowPlaceholder;
 }
-
 function useCanShowPlaceholder(editor) {
   const [canShowPlaceholder, setCanShowPlaceholder] = react.useState(() => canShowPlaceholderFromCurrentEditorState(editor));
   useLayoutEffect(() => {
@@ -49,7 +48,6 @@ function useCanShowPlaceholder(editor) {
       const currentCanShowPlaceholder = canShowPlaceholderFromCurrentEditorState(editor);
       setCanShowPlaceholder(currentCanShowPlaceholder);
     }
-
     resetCanShowPlaceholder();
     return utils.mergeRegister(editor.registerUpdateListener(() => {
       resetCanShowPlaceholder();

package/DEPRECATED_useLexicalPlainText.dev.js

@@ -44,6 +44,7 @@ function useLexicalHistory(editor, externalHistoryState, delay = 1000) {
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -65,7 +66,9 @@ var useLayoutEffect = useLayoutEffectImpl;
  */
 function usePlainTextSetup(editor) {
   useLayoutEffect(() => {
-    return utils.mergeRegister(plainText.registerPlainText(editor), dragon.registerDragonSupport(editor)); // We only do this for init
+    return utils.mergeRegister(plainText.registerPlainText(editor), dragon.registerDragonSupport(editor));
+
+    // We only do this for init
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }

package/DEPRECATED_useLexicalRichText.dev.js

@@ -44,6 +44,7 @@ function useLexicalHistory(editor, externalHistoryState, delay = 1000) {
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -65,7 +66,9 @@ var useLayoutEffect = useLayoutEffectImpl;
  */
 function useRichTextSetup(editor) {
   useLayoutEffect(() => {
-    return utils.mergeRegister(richText.registerRichText(editor), dragon.registerDragonSupport(editor)); // We only do this for init
+    return utils.mergeRegister(richText.registerRichText(editor), dragon.registerDragonSupport(editor));
+
+    // We only do this for init
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [editor]);
 }

package/LexicalAutoEmbedPlugin.dev.js

@@ -28,7 +28,6 @@ class AutoEmbedOption extends LexicalTypeaheadMenuPlugin.TypeaheadOption {
     this.title = title;
     this.onSelect = options.onSelect.bind(this);
   }
-
 }
 function LexicalAutoEmbedPlugin({
   embedConfigs,
@@ -46,12 +45,10 @@ function LexicalAutoEmbedPlugin({
   const checkIfLinkNodeIsEmbeddable = React.useCallback(key => {
     editor.getEditorState().read(async () => {
       const linkNode = lexical.$getNodeByKey(key);
-
       if (link.$isLinkNode(linkNode)) {
         for (let i = 0; i < embedConfigs.length; i++) {
           const embedConfig = embedConfigs[i];
           const urlMatch = await Promise.resolve(embedConfig.parseUrl(linkNode.__url));
-
           if (urlMatch != null) {
             setActiveEmbedConfig(embedConfig);
             setNodeKey(linkNode.getKey());
@@ -73,7 +70,6 @@ function LexicalAutoEmbedPlugin({
         }
       }
     };
-
     return utils.mergeRegister(...[link.LinkNode, link.AutoLinkNode].map(Klass => editor.registerMutationListener(Klass, (...args) => listener(...args))));
   }, [checkIfLinkNodeIsEmbeddable, editor, embedConfigs, nodeKey, reset]);
   React.useEffect(() => {
@@ -81,12 +77,10 @@ function LexicalAutoEmbedPlugin({
       const embedConfig = embedConfigs.find(({
         type
       }) => type === embedConfigType);
-
       if (embedConfig) {
         onOpenEmbedModalForConfig(embedConfig);
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_EDITOR);
   }, [editor, embedConfigs, onOpenEmbedModalForConfig]);
@@ -94,21 +88,16 @@ function LexicalAutoEmbedPlugin({
     if (activeEmbedConfig != null && nodeKey != null) {
       const linkNode = editor.getEditorState().read(() => {
         const node = lexical.$getNodeByKey(nodeKey);
-
         if (link.$isLinkNode(node)) {
           return node;
         }
-
         return null;
       });
-
       if (link.$isLinkNode(linkNode)) {
         const result = await Promise.resolve(activeEmbedConfig.parseUrl(linkNode.__url));
-
         if (result != null) {
           editor.update(() => {
             activeEmbedConfig.insertNode(editor, result);
-
             if (linkNode.isAttached()) {
               linkNode.remove();
             }

package/LexicalAutoFocusPlugin.dev.js

@@ -28,7 +28,6 @@ function AutoFocusPlugin({
       // of this plugin, which should preserve focus too.
       const activeElement = document.activeElement;
       const rootElement = editor.getRootElement();
-
       if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) {
         // Note: preventScroll won't work in Webkit.
         rootElement.focus({

package/LexicalAutoLinkPlugin.dev.js

@@ -19,86 +19,65 @@ var react = require('react');
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function findFirstMatch(text, matchers) {
   for (let i = 0; i < matchers.length; i++) {
     const match = matchers[i](text);
-
     if (match) {
       return match;
     }
   }
-
   return null;
 }
-
 const PUNCTUATION_OR_SPACE = /[.,;\s]/;
-
 function isSeparator(char) {
   return PUNCTUATION_OR_SPACE.test(char);
 }
-
 function endsWithSeparator(textContent) {
   return isSeparator(textContent[textContent.length - 1]);
 }
-
 function startsWithSeparator(textContent) {
   return isSeparator(textContent[0]);
 }
-
 function isPreviousNodeValid(node) {
   let previousNode = node.getPreviousSibling();
-
   if (lexical.$isElementNode(previousNode)) {
     previousNode = previousNode.getLastDescendant();
   }
-
   return previousNode === null || lexical.$isLineBreakNode(previousNode) || lexical.$isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent());
 }
-
 function isNextNodeValid(node) {
   let nextNode = node.getNextSibling();
-
   if (lexical.$isElementNode(nextNode)) {
     nextNode = nextNode.getFirstDescendant();
   }
-
   return nextNode === null || lexical.$isLineBreakNode(nextNode) || lexical.$isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent());
 }
-
 function isContentAroundIsValid(matchStart, matchEnd, text, node) {
   const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node);
-
   if (!contentBeforeIsValid) {
     return false;
   }
-
   const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node);
   return contentAfterIsValid;
 }
-
 function handleLinkCreation(node, matchers, onChange) {
   const nodeText = node.getTextContent();
   let text = nodeText;
   let invalidMatchEnd = 0;
   let remainingTextNode = node;
   let match;
-
   while ((match = findFirstMatch(text, matchers)) && match !== null) {
     const matchStart = match.index;
     const matchLength = match.length;
     const matchEnd = matchStart + matchLength;
     const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, nodeText, node);
-
     if (isValid) {
       let linkTextNode;
-
       if (invalidMatchEnd + matchStart === 0) {
         [linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchLength);
       } else {
         [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchStart, invalidMatchEnd + matchStart + matchLength);
       }
-
       const linkNode = link.$createAutoLinkNode(match.url, match.attributes);
       const textNode = lexical.$createTextNode(match.text);
       textNode.setFormat(linkTextNode.getFormat());
@@ -110,97 +89,80 @@ function handleLinkCreation(node, matchers, onChange) {
     } else {
       invalidMatchEnd += matchEnd;
     }
-
     text = text.substring(matchEnd);
   }
 }
-
 function handleLinkEdit(linkNode, matchers, onChange) {
   // Check children are simple text
   const children = linkNode.getChildren();
   const childrenLength = children.length;
-
   for (let i = 0; i < childrenLength; i++) {
     const child = children[i];
-
     if (!lexical.$isTextNode(child) || !child.isSimpleText()) {
       replaceWithChildren(linkNode);
       onChange(null, linkNode.getURL());
       return;
     }
-  } // Check text content fully matches
-
+  }
 
+  // Check text content fully matches
   const text = linkNode.getTextContent();
   const match = findFirstMatch(text, matchers);
-
   if (match === null || match.text !== text) {
     replaceWithChildren(linkNode);
     onChange(null, linkNode.getURL());
     return;
-  } // Check neighbors
-
+  }
 
+  // Check neighbors
   if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {
     replaceWithChildren(linkNode);
     onChange(null, linkNode.getURL());
     return;
   }
-
   const url = linkNode.getURL();
-
   if (url !== match.url) {
     linkNode.setURL(match.url);
     onChange(match.url, url);
   }
-
   if (match.attributes) {
     const rel = linkNode.getRel();
-
     if (rel !== match.attributes.rel) {
       linkNode.setRel(match.attributes.rel || null);
       onChange(match.attributes.rel || null, rel);
     }
-
     const target = linkNode.getTarget();
-
     if (target !== match.attributes.target) {
       linkNode.setTarget(match.attributes.target || null);
       onChange(match.attributes.target || null, target);
     }
   }
-} // Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.
-// Given the creation preconditions, these can only be simple text nodes.
-
+}
 
+// Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.
+// Given the creation preconditions, these can only be simple text nodes.
 function handleBadNeighbors(textNode, onChange) {
   const previousSibling = textNode.getPreviousSibling();
   const nextSibling = textNode.getNextSibling();
   const text = textNode.getTextContent();
-
   if (link.$isAutoLinkNode(previousSibling) && !startsWithSeparator(text)) {
     replaceWithChildren(previousSibling);
     onChange(null, previousSibling.getURL());
   }
-
   if (link.$isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {
     replaceWithChildren(nextSibling);
     onChange(null, nextSibling.getURL());
   }
 }
-
 function replaceWithChildren(node) {
   const children = node.getChildren();
   const childrenLength = children.length;
-
   for (let j = childrenLength - 1; j >= 0; j--) {
     node.insertAfter(children[j]);
   }
-
   node.remove();
   return children.map(child => child.getLatest());
 }
-
 function useAutoLink(editor, matchers, onChange) {
   react.useEffect(() => {
     if (!editor.hasNodes([link.AutoLinkNode])) {
@@ -208,29 +170,24 @@ function useAutoLink(editor, matchers, onChange) {
         throw Error(`LexicalAutoLinkPlugin: AutoLinkNode not registered on editor`);
       }
     }
-
     const onChangeWrapped = (url, prevUrl) => {
       if (onChange) {
         onChange(url, prevUrl);
       }
     };
-
     return utils.mergeRegister(editor.registerNodeTransform(lexical.TextNode, textNode => {
       const parent = textNode.getParentOrThrow();
-
       if (link.$isAutoLinkNode(parent)) {
         handleLinkEdit(parent, matchers, onChangeWrapped);
       } else if (!link.$isLinkNode(parent)) {
         if (textNode.isSimpleText()) {
           handleLinkCreation(textNode, matchers, onChangeWrapped);
         }
-
         handleBadNeighbors(textNode, onChangeWrapped);
       }
     }));
   }, [editor, matchers, onChange]);
 }
-
 function AutoLinkPlugin({
   matchers,
   onChange

package/LexicalBlockWithAlignableContents.dev.js

@@ -34,31 +34,25 @@ function BlockWithAlignableContents({
       event.preventDefault();
       editor.update(() => {
         const node = lexical.$getNodeByKey(nodeKey);
-
         if (lexical.$isDecoratorNode(node)) {
           node.remove();
         }
-
         setSelected(false);
       });
     }
-
     return false;
   }, [editor, isSelected, nodeKey, setSelected]);
   React.useEffect(() => {
     return utils.mergeRegister(editor.registerCommand(lexical.FORMAT_ELEMENT_COMMAND, formatType => {
       if (isSelected) {
         const selection = lexical.$getSelection();
-
         if (lexical.$isNodeSelection(selection)) {
           const node = lexical.$getNodeByKey(nodeKey);
-
           if (LexicalDecoratorBlockNode.$isDecoratorBlockNode(node)) {
             node.setFormat(formatType);
           }
         } else if (lexical.$isRangeSelection(selection)) {
           const nodes = selection.getNodes();
-
           for (const node of nodes) {
             if (LexicalDecoratorBlockNode.$isDecoratorBlockNode(node)) {
               node.setFormat(formatType);
@@ -68,23 +62,18 @@ function BlockWithAlignableContents({
             }
           }
         }
-
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.CLICK_COMMAND, event => {
       if (event.target === ref.current) {
         event.preventDefault();
-
         if (!event.shiftKey) {
           clearSelection();
         }
-
         setSelected(!isSelected);
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_DELETE_COMMAND, onDelete, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, onDelete, lexical.COMMAND_PRIORITY_LOW));
   }, [clearSelection, editor, isSelected, nodeKey, onDelete, setSelected]);