@lexical/react 0.12.2 → 0.12.3

package/LexicalCharacterLimitPlugin.dev.js

@@ -46,16 +46,13 @@ function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({}))
     }) => {
       const isComposing = editor.isComposing();
       const hasContentChanges = dirtyLeaves.size > 0 || dirtyElements.size > 0;
-
       if (isComposing || !hasContentChanges) {
         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(() => {
@@ -64,75 +61,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();
@@ -145,12 +129,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);
         }
@@ -158,59 +141,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 {
@@ -218,28 +191,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();
 }
 
@@ -252,31 +220,24 @@ function mergePrevious(overflowNode) {
  */
 const CHARACTER_LIMIT = 5;
 let textEncoderInstance = null;
-
 function textEncoder() {
   if (window.TextEncoder === undefined) {
     return null;
   }
-
   if (textEncoderInstance === null) {
     textEncoderInstance = new window.TextEncoder();
   }
-
   return textEncoderInstance;
 }
-
 function utf8Length(text) {
   const currentTextEncoder = textEncoder();
-
   if (currentTextEncoder === null) {
     // http://stackoverflow.com/a/5515960/210370
     const m = encodeURIComponent(text).match(/%[89ABab]/g);
     return text.length + (m ? m.length : 0);
   }
-
   return currentTextEncoder.encode(text).length;
 }
-
 function CharacterLimitPlugin({
   charset = 'UTF-16',
   maxLength = CHARACTER_LIMIT

package/LexicalCheckListPlugin.dev.js

@@ -31,25 +31,19 @@ function CheckListPlugin() {
       return handleArrownUpOrDown(event, editor, true);
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, event => {
       const activeItem = getActiveCheckListItem();
-
       if (activeItem != null) {
         const rootElement = editor.getRootElement();
-
         if (rootElement != null) {
           rootElement.focus();
         }
-
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_SPACE_COMMAND, event => {
       const activeItem = getActiveCheckListItem();
-
       if (activeItem != null && editor.isEditable()) {
         editor.update(() => {
           const listItemNode = lexical.$getNearestNodeFromDOMNode(activeItem);
-
           if (list.$isListItemNode(listItemNode)) {
             event.preventDefault();
             listItemNode.toggleChecked();
@@ -57,28 +51,22 @@ function CheckListPlugin() {
         });
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, event => {
       return editor.getEditorState().read(() => {
         const selection = lexical.$getSelection();
-
         if (lexical.$isRangeSelection(selection) && selection.isCollapsed()) {
           const {
             anchor
           } = selection;
           const isElement = anchor.type === 'element';
-
           if (isElement || anchor.offset === 0) {
             const anchorNode = anchor.getNode();
             const elementNode = utils.$findMatchingParent(anchorNode, node => lexical.$isElementNode(node) && !node.isInline());
-
             if (list.$isListItemNode(elementNode)) {
               const parent = elementNode.getParent();
-
               if (list.$isListNode(parent) && parent.getListType() === 'check' && (isElement || elementNode.getFirstDescendant() === anchorNode)) {
                 const domNode = editor.getElementByKey(elementNode.__key);
-
                 if (domNode != null && document.activeElement !== domNode) {
                   domNode.focus();
                   event.preventDefault();
@@ -88,7 +76,6 @@ function CheckListPlugin() {
             }
           }
         }
-
         return false;
       });
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerRootListener((rootElement, prevElement) => {
@@ -96,7 +83,6 @@ function CheckListPlugin() {
         rootElement.addEventListener('click', handleClick);
         rootElement.addEventListener('pointerdown', handlePointerDown);
       }
-
       if (prevElement !== null) {
         prevElement.removeEventListener('click', handleClick);
         prevElement.removeEventListener('pointerdown', handlePointerDown);
@@ -105,45 +91,37 @@ function CheckListPlugin() {
   });
   return null;
 }
-
 function handleCheckItemEvent(event, callback) {
   const target = event.target;
-
   if (target === null || !utils.isHTMLElement(target)) {
     return;
-  } // Ignore clicks on LI that have nested lists
-
+  }
 
+  // Ignore clicks on LI that have nested lists
   const firstChild = target.firstChild;
-
   if (firstChild != null && utils.isHTMLElement(firstChild) && (firstChild.tagName === 'UL' || firstChild.tagName === 'OL')) {
     return;
   }
+  const parentNode = target.parentNode;
 
-  const parentNode = target.parentNode; // @ts-ignore internal field
-
+  // @ts-ignore internal field
   if (!parentNode || parentNode.__lexicalListType !== 'check') {
     return;
   }
-
   const pageX = event.pageX;
   const rect = target.getBoundingClientRect();
-
   if (target.dir === 'rtl' ? pageX < rect.right && pageX > rect.right - 20 : pageX > rect.left && pageX < rect.left + 20) {
     callback();
   }
 }
-
 function handleClick(event) {
   handleCheckItemEvent(event, () => {
     const domNode = event.target;
     const editor = findEditor(domNode);
-
     if (editor != null && editor.isEditable()) {
       editor.update(() => {
         if (event.target) {
           const node = lexical.$getNearestNodeFromDOMNode(domNode);
-
           if (list.$isListItemNode(node)) {
             domNode.focus();
             node.toggleChecked();
@@ -153,80 +131,65 @@ function handleClick(event) {
     }
   });
 }
-
 function handlePointerDown(event) {
   handleCheckItemEvent(event, () => {
     // Prevents caret moving when clicking on check mark
     event.preventDefault();
   });
 }
-
 function findEditor(target) {
   let node = target;
-
   while (node) {
     // @ts-ignore internal field
     if (node.__lexicalEditor) {
       // @ts-ignore internal field
       return node.__lexicalEditor;
     }
-
     node = node.parentNode;
   }
-
   return null;
 }
-
 function getActiveCheckListItem() {
   const activeElement = document.activeElement;
-  return activeElement != null && activeElement.tagName === 'LI' && activeElement.parentNode != null && // @ts-ignore internal field
+  return activeElement != null && activeElement.tagName === 'LI' && activeElement.parentNode != null &&
+  // @ts-ignore internal field
   activeElement.parentNode.__lexicalListType === 'check' ? activeElement : null;
 }
-
 function findCheckListItemSibling(node, backward) {
   let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
-  let parent = node; // Going up in a tree to get non-null sibling
+  let parent = node;
 
+  // Going up in a tree to get non-null sibling
   while (sibling == null && list.$isListItemNode(parent)) {
     // Get li -> parent ul/ol -> parent li
     parent = parent.getParentOrThrow().getParent();
-
     if (parent != null) {
       sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
     }
-  } // Going down in a tree to get first non-nested list item
-
+  }
 
+  // Going down in a tree to get first non-nested list item
   while (list.$isListItemNode(sibling)) {
     const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();
-
     if (!list.$isListNode(firstChild)) {
       return sibling;
     }
-
     sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();
   }
-
   return null;
 }
-
 function handleArrownUpOrDown(event, editor, backward) {
   const activeItem = getActiveCheckListItem();
-
   if (activeItem != null) {
     editor.update(() => {
       const listItem = lexical.$getNearestNodeFromDOMNode(activeItem);
-
       if (!list.$isListItemNode(listItem)) {
         return;
       }
-
       const nextListItem = findCheckListItemSibling(listItem, backward);
-
       if (nextListItem != null) {
         nextListItem.selectStart();
         const dom = editor.getElementByKey(nextListItem.__key);
-
         if (dom != null) {
           event.preventDefault();
           setTimeout(() => {
@@ -236,7 +199,6 @@ function handleArrownUpOrDown(event, editor, backward) {
       }
     });
   }
-
   return false;
 }
 

package/LexicalClearEditorPlugin.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';
 
 /**
@@ -49,7 +50,6 @@ function ClearEditorPlugin({
           const paragraph = lexical.$createParagraphNode();
           root.clear();
           root.append(paragraph);
-
           if (selection !== null) {
             paragraph.select();
           }

package/LexicalClickableLinkPlugin.dev.js

@@ -19,21 +19,16 @@ var react = require('react');
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function findMatchingDOM(startNode, predicate) {
   let node = startNode;
-
   while (node != null) {
     if (predicate(node)) {
       return node;
     }
-
     node = node.parentNode;
   }
-
   return null;
 }
-
 function LexicalClickableLinkPlugin({
   newTab = true
 }) {
@@ -41,31 +36,24 @@ function LexicalClickableLinkPlugin({
   react.useEffect(() => {
     const onClick = event => {
       const target = event.target;
-
       if (!(target instanceof Node)) {
         return;
       }
-
       const nearestEditor = lexical.getNearestEditorFromDOMNode(target);
-
       if (nearestEditor === null) {
         return;
       }
-
       let url = null;
       let urlTarget = null;
       nearestEditor.update(() => {
         const clickedNode = lexical.$getNearestNodeFromDOMNode(target);
-
         if (clickedNode !== null) {
           const maybeLinkNode = utils.$findMatchingParent(clickedNode, lexical.$isElementNode);
-
           if (link.$isLinkNode(maybeLinkNode)) {
             url = maybeLinkNode.getURL();
             urlTarget = maybeLinkNode.getTarget();
           } else {
             const a = findMatchingDOM(target, utils.isHTMLAnchorElement);
-
             if (a !== null) {
               url = a.href;
               urlTarget = a.target;
@@ -73,36 +61,30 @@ function LexicalClickableLinkPlugin({
           }
         }
       });
-
       if (url === null || url === '') {
         return;
-      } // Allow user to select link text without follwing url
-
+      }
 
+      // Allow user to select link text without follwing url
       const selection = editor.getEditorState().read(lexical.$getSelection);
-
       if (lexical.$isRangeSelection(selection) && !selection.isCollapsed()) {
         event.preventDefault();
         return;
       }
-
       const isMiddle = event.type === 'auxclick' && event.button === 1;
       window.open(url, newTab || isMiddle || event.metaKey || event.ctrlKey || urlTarget === '_blank' ? '_blank' : '_self');
       event.preventDefault();
     };
-
     const onMouseUp = event => {
       if (event.button === 1 && editor.isEditable()) {
         onClick(event);
       }
     };
-
     return editor.registerRootListener((rootElement, prevRootElement) => {
       if (prevRootElement !== null) {
         prevRootElement.removeEventListener('click', onClick);
         prevRootElement.removeEventListener('mouseup', onMouseUp);
       }
-
       if (rootElement !== null) {
         rootElement.addEventListener('click', onClick);
         rootElement.addEventListener('mouseup', onMouseUp);

package/LexicalCollaborationContext.dev.js

@@ -26,15 +26,12 @@ const CollaborationContext = /*#__PURE__*/react.createContext({
 });
 function useCollaborationContext(username, color) {
   const collabContext = react.useContext(CollaborationContext);
-
   if (username != null) {
     collabContext.name = username;
   }
-
   if (color != null) {
     collabContext.color = color;
   }
-
   return collabContext;
 }