@lexical/link 0.8.1 → 0.9.1

package/LexicalLink.dev.js

@@ -10,6 +10,7 @@ var utils = require('@lexical/utils');
 var lexical = require('lexical');
 
 /** @module @lexical/link */
+
 /** @noInheritDoc */
 class LinkNode extends lexical.ElementNode {
   /** @internal */
@@ -17,16 +18,17 @@ class LinkNode extends lexical.ElementNode {
   /** @internal */
 
   /** @internal */
-
   static getType() {
     return 'link';
   }
+
   static clone(node) {
     return new LinkNode(node.__url, {
       rel: node.__rel,
       target: node.__target
     }, node.__key);
   }
+
   constructor(url, attributes = {}, key) {
     super(key);
     const {
@@ -37,25 +39,32 @@ class LinkNode extends lexical.ElementNode {
     this.__target = target;
     this.__rel = rel;
   }
+
   createDOM(config) {
     const element = document.createElement('a');
     element.href = this.__url;
+
     if (this.__target !== null) {
       element.target = this.__target;
     }
+
     if (this.__rel !== null) {
       element.rel = this.__rel;
     }
+
     utils.addClassNamesToElement(element, config.theme.link);
     return element;
   }
+
   updateDOM(prevNode, anchor, config) {
     const url = this.__url;
     const target = this.__target;
     const rel = this.__rel;
+
     if (url !== prevNode.__url) {
       anchor.href = url;
     }
+
     if (target !== prevNode.__target) {
       if (target) {
         anchor.target = target;
@@ -63,6 +72,7 @@ class LinkNode extends lexical.ElementNode {
         anchor.removeAttribute('target');
       }
     }
+
     if (rel !== prevNode.__rel) {
       if (rel) {
         anchor.rel = rel;
@@ -70,8 +80,10 @@ class LinkNode extends lexical.ElementNode {
         anchor.removeAttribute('rel');
       }
     }
+
     return false;
   }
+
   static importDOM() {
     return {
       a: node => ({
@@ -80,6 +92,7 @@ class LinkNode extends lexical.ElementNode {
       })
     };
   }
+
   static importJSON(serializedNode) {
     const node = $createLinkNode(serializedNode.url, {
       rel: serializedNode.rel,
@@ -90,9 +103,9 @@ class LinkNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
+
   exportJSON() {
-    return {
-      ...super.exportJSON(),
+    return { ...super.exportJSON(),
       rel: this.getRel(),
       target: this.getTarget(),
       type: 'link',
@@ -100,29 +113,37 @@ class LinkNode extends lexical.ElementNode {
       version: 1
     };
   }
+
   getURL() {
     return this.getLatest().__url;
   }
+
   setURL(url) {
     const writable = this.getWritable();
     writable.__url = url;
   }
+
   getTarget() {
     return this.getLatest().__target;
   }
+
   setTarget(target) {
     const writable = this.getWritable();
     writable.__target = target;
   }
+
   getRel() {
     return this.getLatest().__rel;
   }
+
   setRel(rel) {
     const writable = this.getWritable();
     writable.__rel = rel;
   }
+
   insertNewAfter(selection, restoreSelection = true) {
     const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
+
     if (lexical.$isElementNode(element)) {
       const linkNode = $createLinkNode(this.__url, {
         rel: this.__rel,
@@ -131,33 +152,44 @@ class LinkNode extends lexical.ElementNode {
       element.append(linkNode);
       return linkNode;
     }
+
     return null;
   }
+
   canInsertTextBefore() {
     return false;
   }
+
   canInsertTextAfter() {
     return false;
   }
+
   canBeEmpty() {
     return false;
   }
+
   isInline() {
     return true;
   }
+
   extractWithChild(child, selection, destination) {
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     const anchorNode = selection.anchor.getNode();
     const focusNode = selection.focus.getNode();
     return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && selection.getTextContent().length > 0;
   }
+
 }
+
 function convertAnchorElement(domNode) {
   let node = null;
+
   if (utils.isHTMLAnchorElement(domNode)) {
     const content = domNode.textContent;
+
     if (content !== null && content !== '') {
       node = $createLinkNode(domNode.getAttribute('href') || '', {
         rel: domNode.getAttribute('rel'),
@@ -165,10 +197,12 @@ function convertAnchorElement(domNode) {
       });
     }
   }
+
   return {
     node
   };
 }
+
 function $createLinkNode(url, attributes) {
   return lexical.$applyNodeReplacement(new LinkNode(url, attributes));
 }
@@ -181,12 +215,14 @@ class AutoLinkNode extends LinkNode {
   static getType() {
     return 'autolink';
   }
+
   static clone(node) {
     return new AutoLinkNode(node.__url, {
       rel: node.__rel,
       target: node.__target
     }, node.__key);
   }
+
   static importJSON(serializedNode) {
     const node = $createAutoLinkNode(serializedNode.url, {
       rel: serializedNode.rel,
@@ -197,19 +233,22 @@ class AutoLinkNode extends LinkNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
+
   static importDOM() {
     // TODO: Should link node should handle the import over autolink?
     return null;
   }
+
   exportJSON() {
-    return {
-      ...super.exportJSON(),
+    return { ...super.exportJSON(),
       type: 'autolink',
       version: 1
     };
   }
+
   insertNewAfter(selection, restoreSelection = true) {
     const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
+
     if (lexical.$isElementNode(element)) {
       const linkNode = $createAutoLinkNode(this.__url, {
         rel: this._rel,
@@ -218,8 +257,10 @@ class AutoLinkNode extends LinkNode {
       element.append(linkNode);
       return linkNode;
     }
+
     return null;
   }
+
 }
 function $createAutoLinkNode(url, attributes) {
   return lexical.$applyNodeReplacement(new AutoLinkNode(url, attributes));
@@ -234,64 +275,82 @@ function toggleLink(url, attributes = {}) {
   } = attributes;
   const rel = attributes.rel === undefined ? 'noopener' : attributes.rel;
   const selection = lexical.$getSelection();
+
   if (!lexical.$isRangeSelection(selection)) {
     return;
   }
+
   const nodes = selection.extract();
+
   if (url === null) {
     // Remove LinkNodes
     nodes.forEach(node => {
       const parent = node.getParent();
+
       if ($isLinkNode(parent)) {
         const children = parent.getChildren();
+
         for (let i = 0; i < children.length; i++) {
           parent.insertBefore(children[i]);
         }
+
         parent.remove();
       }
     });
   } else {
     // Add or merge LinkNodes
     if (nodes.length === 1) {
-      const firstNode = nodes[0];
-      // if the first node is a LinkNode or if its
+      const firstNode = nodes[0]; // if the first node is a LinkNode or if its
       // parent is a LinkNode, we update the URL, target and rel.
+
       const linkNode = $isLinkNode(firstNode) ? firstNode : $getLinkAncestor(firstNode);
+
       if (linkNode !== null) {
         linkNode.setURL(url);
+
         if (target !== undefined) {
           linkNode.setTarget(target);
         }
+
         if (rel !== null) {
           linkNode.setRel(rel);
         }
+
         return;
       }
     }
+
     let prevParent = null;
     let linkNode = null;
     nodes.forEach(node => {
       const parent = node.getParent();
+
       if (parent === linkNode || parent === null || lexical.$isElementNode(node) && !node.isInline()) {
         return;
       }
+
       if ($isLinkNode(parent)) {
         linkNode = parent;
         parent.setURL(url);
+
         if (target !== undefined) {
           parent.setTarget(target);
         }
+
         if (rel !== null) {
           linkNode.setRel(rel);
         }
+
         return;
       }
+
       if (!parent.is(prevParent)) {
         prevParent = parent;
         linkNode = $createLinkNode(url, {
           rel,
           target
         });
+
         if ($isLinkNode(parent)) {
           if (node.getPreviousSibling() === null) {
             parent.insertBefore(linkNode);
@@ -302,31 +361,40 @@ function toggleLink(url, attributes = {}) {
           node.insertBefore(linkNode);
         }
       }
+
       if ($isLinkNode(node)) {
         if (node.is(linkNode)) {
           return;
         }
+
         if (linkNode !== null) {
           const children = node.getChildren();
+
           for (let i = 0; i < children.length; i++) {
             linkNode.append(children[i]);
           }
         }
+
         node.remove();
         return;
       }
+
       if (linkNode !== null) {
         linkNode.append(node);
       }
     });
   }
 }
+
 function $getLinkAncestor(node) {
   return $getAncestor(node, ancestor => $isLinkNode(ancestor));
 }
+
 function $getAncestor(node, predicate) {
   let parent = node;
+
   while (parent !== null && (parent = parent.getParent()) !== null && !predicate(parent));
+
   return parent;
 }
 

package/package.json

@@ -8,13 +8,13 @@
     "link"
   ],
   "license": "MIT",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "main": "LexicalLink.js",
   "peerDependencies": {
-    "lexical": "0.8.1"
+    "lexical": "0.9.1"
   },
   "dependencies": {
-    "@lexical/utils": "0.8.1"
+    "@lexical/utils": "0.9.1"
   },
   "repository": {
     "type": "git",