@lexical/clipboard 0.7.8 → 0.7.9

package/LexicalClipboard.dev.js

@@ -20,84 +20,75 @@ var lexical = require('lexical');
  */
 function $getHtmlContent(editor) {
   const selection = lexical.$getSelection();
-
   if (selection == null) {
     {
       throw Error(`Expected valid LexicalSelection`);
     }
-  } // If we haven't selected anything
-
+  }
 
+  // If we haven't selected anything
   if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
     return '';
   }
-
   return html.$generateHtmlFromNodes(editor, selection);
-} // TODO 0.6.0 Return a blank string instead
-// TODO 0.6.0 Rename to $getJSON
+}
 
+// TODO 0.6.0 Return a blank string instead
+// TODO 0.6.0 Rename to $getJSON
 function $getLexicalContent(editor) {
   const selection = lexical.$getSelection();
-
   if (selection == null) {
     {
       throw Error(`Expected valid LexicalSelection`);
     }
-  } // If we haven't selected anything
-
+  }
 
+  // If we haven't selected anything
   if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
     return null;
   }
-
   return JSON.stringify($generateJSONFromSelectedNodes(editor, selection));
 }
 function $insertDataTransferForPlainText(dataTransfer, selection) {
   const text = dataTransfer.getData('text/plain');
-
   if (text != null) {
     selection.insertRawText(text);
   }
 }
 function $insertDataTransferForRichText(dataTransfer, selection, editor) {
   const lexicalString = dataTransfer.getData('application/x-lexical-editor');
-
   if (lexicalString) {
     try {
       const payload = JSON.parse(lexicalString);
-
       if (payload.namespace === editor._config.namespace && Array.isArray(payload.nodes)) {
         const nodes = $generateNodesFromSerializedNodes(payload.nodes);
         return $insertGeneratedNodes(editor, nodes, selection);
       }
-    } catch {// Fail silently.
+    } catch {
+      // Fail silently.
     }
   }
-
   const htmlString = dataTransfer.getData('text/html');
-
   if (htmlString) {
     try {
       const parser = new DOMParser();
       const dom = parser.parseFromString(htmlString, 'text/html');
       const nodes = html.$generateNodesFromDOM(editor, dom);
       return $insertGeneratedNodes(editor, nodes, selection);
-    } catch {// Fail silently.
+    } catch {
+      // Fail silently.
     }
-  } // Multi-line plain text in rich text mode pasted as separate paragraphs
-  // instead of single paragraph with linebreaks.
-
+  }
 
+  // Multi-line plain text in rich text mode pasted as separate paragraphs
+  // instead of single paragraph with linebreaks.
   const text = dataTransfer.getData('text/plain');
-
   if (text != null) {
     if (lexical.$isRangeSelection(selection)) {
       const lines = text.split(/\r?\n/);
       const linesLength = lines.length;
-
       for (let i = 0; i < linesLength; i++) {
         selection.insertText(lines[i]);
-
         if (i < linesLength - 1) {
           selection.insertParagraph();
         }
@@ -109,36 +100,30 @@ function $insertDataTransferForRichText(dataTransfer, selection, editor) {
 }
 function $insertGeneratedNodes(editor, nodes, selection) {
   const isSelectionInsideOfGrid = lexical.DEPRECATED_$isGridSelection(selection) || utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.DEPRECATED_$isGridCellNode(n)) !== null && utils.$findMatchingParent(selection.focus.getNode(), n => lexical.DEPRECATED_$isGridCellNode(n)) !== null;
-
   if (isSelectionInsideOfGrid && nodes.length === 1 && lexical.DEPRECATED_$isGridNode(nodes[0])) {
     $mergeGridNodesStrategy(nodes, selection, false, editor);
     return;
   }
-
   $basicInsertStrategy(nodes, selection);
   return;
 }
-
 function $basicInsertStrategy(nodes, selection) {
   // Wrap text and inline nodes in paragraph nodes so we have all blocks at the top-level
   const topLevelBlocks = [];
   let currentBlock = null;
-
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const isLineBreakNode = lexical.$isLineBreakNode(node);
-
     if (isLineBreakNode || lexical.$isDecoratorNode(node) && node.isInline() || lexical.$isElementNode(node) && node.isInline() || lexical.$isTextNode(node) || node.isParentRequired()) {
       if (currentBlock === null) {
         currentBlock = node.createParentElementNode();
-        topLevelBlocks.push(currentBlock); // In the case of LineBreakNode, we just need to
+        topLevelBlocks.push(currentBlock);
+        // In the case of LineBreakNode, we just need to
         // add an empty ParagraphNode to the topLevelBlocks.
-
         if (isLineBreakNode) {
           continue;
         }
       }
-
       if (currentBlock !== null) {
         currentBlock.append(node);
       }
@@ -147,30 +132,25 @@ function $basicInsertStrategy(nodes, selection) {
       currentBlock = null;
     }
   }
-
   if (lexical.$isRangeSelection(selection)) {
     selection.insertNodes(topLevelBlocks);
   } else if (lexical.DEPRECATED_$isGridSelection(selection)) {
     // If there's an active grid selection and a non grid is pasted, add to the anchor.
     const anchorCell = selection.anchor.getNode();
-
     if (!lexical.DEPRECATED_$isGridCellNode(anchorCell)) {
       {
         throw Error(`Expected Grid Cell in Grid Selection`);
       }
     }
-
     anchorCell.append(...topLevelBlocks);
   }
 }
-
 function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   if (nodes.length !== 1 || !lexical.DEPRECATED_$isGridNode(nodes[0])) {
     {
       throw Error(`$mergeGridNodesStrategy: Expected Grid insertion.`);
     }
   }
-
   const newGrid = nodes[0];
   const newGridRows = newGrid.getChildren();
   const newColumnCount = newGrid.getFirstChildOrThrow().getChildrenSize();
@@ -178,13 +158,11 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   const gridCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.DEPRECATED_$isGridCellNode(n));
   const gridRowNode = gridCellNode && utils.$findMatchingParent(gridCellNode, n => lexical.DEPRECATED_$isGridRowNode(n));
   const gridNode = gridRowNode && utils.$findMatchingParent(gridRowNode, n => lexical.DEPRECATED_$isGridNode(n));
-
   if (!lexical.DEPRECATED_$isGridCellNode(gridCellNode) || !lexical.DEPRECATED_$isGridRowNode(gridRowNode) || !lexical.DEPRECATED_$isGridNode(gridNode)) {
     {
       throw Error(`$mergeGridNodesStrategy: Expected selection to be inside of a Grid.`);
     }
   }
-
   const startY = gridRowNode.getIndexWithinParent();
   const stopY = Math.min(gridNode.getChildrenSize() - 1, startY + newRowCount - 1);
   const startX = gridCellNode.getIndexWithinParent();
@@ -197,51 +175,40 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   let newRowIdx = 0;
   let newAnchorCellKey;
   let newFocusCellKey;
-
   for (let r = fromY; r <= toY; r++) {
     const currentGridRowNode = gridRowNodes[r];
-
     if (!lexical.DEPRECATED_$isGridRowNode(currentGridRowNode)) {
       {
         throw Error(`getNodes: expected to find GridRowNode`);
       }
     }
-
     const newGridRowNode = newGridRows[newRowIdx];
-
     if (!lexical.DEPRECATED_$isGridRowNode(newGridRowNode)) {
       {
         throw Error(`getNodes: expected to find GridRowNode`);
       }
     }
-
     const gridCellNodes = currentGridRowNode.getChildren();
     const newGridCellNodes = newGridRowNode.getChildren();
     let newColumnIdx = 0;
-
     for (let c = fromX; c <= toX; c++) {
       const currentGridCellNode = gridCellNodes[c];
-
       if (!lexical.DEPRECATED_$isGridCellNode(currentGridCellNode)) {
         {
           throw Error(`getNodes: expected to find GridCellNode`);
         }
       }
-
       const newGridCellNode = newGridCellNodes[newColumnIdx];
-
       if (!lexical.DEPRECATED_$isGridCellNode(newGridCellNode)) {
         {
           throw Error(`getNodes: expected to find GridCellNode`);
         }
       }
-
       if (r === fromY && c === fromX) {
         newAnchorCellKey = currentGridCellNode.getKey();
       } else if (r === toY && c === toX) {
         newFocusCellKey = currentGridCellNode.getKey();
       }
-
       const originalChildren = currentGridCellNode.getChildren();
       newGridCellNode.getChildren().forEach(child => {
         if (lexical.$isTextNode(child)) {
@@ -255,10 +222,8 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
       originalChildren.forEach(n => n.remove());
       newColumnIdx++;
     }
-
     newRowIdx++;
   }
-
   if (newAnchorCellKey && newFocusCellKey) {
     const newGridSelection = lexical.DEPRECATED_$createGridSelection();
     newGridSelection.set(gridNode.getKey(), newAnchorCellKey, newFocusCellKey);
@@ -266,20 +231,19 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
     editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND, undefined);
   }
 }
-
 function exportNodeToJSON(node) {
   const serializedNode = node.exportJSON();
-  const nodeClass = node.constructor; // @ts-expect-error TODO Replace Class utility type with InstanceType
+  const nodeClass = node.constructor;
 
+  // @ts-expect-error TODO Replace Class utility type with InstanceType
   if (serializedNode.type !== nodeClass.getType()) {
     {
       throw Error(`LexicalNode: Node ${nodeClass.name} does not implement .exportJSON().`);
     }
-  } // @ts-expect-error TODO Replace Class utility type with InstanceType
-
+  }
 
+  // @ts-expect-error TODO Replace Class utility type with InstanceType
   const serializedChildren = serializedNode.children;
-
   if (lexical.$isElementNode(node)) {
     if (!Array.isArray(serializedChildren)) {
       {
@@ -287,50 +251,44 @@ function exportNodeToJSON(node) {
       }
     }
   }
-
   return serializedNode;
 }
-
 function $appendNodesToJSON(editor, selection$1, currentNode, targetArray = []) {
   let shouldInclude = selection$1 != null ? currentNode.isSelected(selection$1) : true;
   const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('html');
   let target = currentNode;
-
   if (selection$1 !== null) {
     let clone = selection.$cloneWithProperties(currentNode);
     clone = lexical.$isTextNode(clone) && selection$1 != null ? selection.$sliceSelectedTextNodeContent(selection$1, clone) : clone;
     target = clone;
   }
-
   const children = lexical.$isElementNode(target) ? target.getChildren() : [];
-  const serializedNode = exportNodeToJSON(target); // TODO: TextNode calls getTextContent() (NOT node.__text) within it's exportJSON method
+  const serializedNode = exportNodeToJSON(target);
+
+  // TODO: TextNode calls getTextContent() (NOT node.__text) within it's exportJSON method
   // which uses getLatest() to get the text from the original node with the same key.
   // This is a deeper issue with the word "clone" here, it's still a reference to the
   // same node as far as the LexicalEditor is concerned since it shares a key.
   // We need a way to create a clone of a Node in memory with it's own key, but
   // until then this hack will work for the selected text extract use case.
-
   if (lexical.$isTextNode(target)) {
-    const text = target.__text; // If an uncollapsed selection ends or starts at the end of a line of specialized,
+    const text = target.__text;
+    // If an uncollapsed selection ends or starts at the end of a line of specialized,
     // TextNodes, such as code tokens, we will get a 'blank' TextNode here, i.e., one
     // with text of length 0. We don't want this, it makes a confusing mess. Reset!
-
     if (text.length > 0) {
       serializedNode.text = text;
     } else {
       shouldInclude = false;
     }
   }
-
   for (let i = 0; i < children.length; i++) {
     const childNode = children[i];
     const shouldIncludeChild = $appendNodesToJSON(editor, selection$1, childNode, serializedNode.children);
-
     if (!shouldInclude && lexical.$isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection$1, 'clone')) {
       shouldInclude = true;
     }
   }
-
   if (shouldInclude && !shouldExclude) {
     targetArray.push(serializedNode);
   } else if (Array.isArray(serializedNode.children)) {
@@ -339,21 +297,18 @@ function $appendNodesToJSON(editor, selection$1, currentNode, targetArray = [])
       targetArray.push(serializedChildNode);
     }
   }
-
   return shouldInclude;
-} // TODO why $ function with Editor instance?
-
+}
 
+// TODO why $ function with Editor instance?
 function $generateJSONFromSelectedNodes(editor, selection) {
   const nodes = [];
   const root = lexical.$getRoot();
   const topLevelChildren = root.getChildren();
-
   for (let i = 0; i < topLevelChildren.length; i++) {
     const topLevelNode = topLevelChildren[i];
     $appendNodesToJSON(editor, selection, topLevelNode, nodes);
   }
-
   return {
     namespace: editor._config.namespace,
     nodes
@@ -361,31 +316,27 @@ function $generateJSONFromSelectedNodes(editor, selection) {
 }
 function $generateNodesFromSerializedNodes(serializedNodes) {
   const nodes = [];
-
   for (let i = 0; i < serializedNodes.length; i++) {
     const serializedNode = serializedNodes[i];
     const node = lexical.$parseSerializedNode(serializedNode);
-
     if (lexical.$isTextNode(node)) {
       selection.$addNodeStyle(node);
     }
-
     nodes.push(node);
   }
-
   return nodes;
 }
 const EVENT_LATENCY = 50;
-let clipboardEventTimeout = null; // TODO custom selection
-// TODO potentially have a node customizable version for plain text
+let clipboardEventTimeout = null;
 
+// TODO custom selection
+// TODO potentially have a node customizable version for plain text
 async function copyToClipboard__EXPERIMENTAL(editor, event) {
   if (clipboardEventTimeout !== null) {
     // Prevent weird race conditions that can happen when this function is run multiple times
     // synchronously. In the future, we can do better, we can cancel/override the previously running job.
     return false;
   }
-
   if (event !== null) {
     return new Promise((resolve, reject) => {
       editor.update(() => {
@@ -393,14 +344,11 @@ async function copyToClipboard__EXPERIMENTAL(editor, event) {
       });
     });
   }
-
   const rootElement = editor.getRootElement();
   const domSelection = document.getSelection();
-
   if (rootElement === null || domSelection === null) {
     return false;
   }
-
   const element = document.createElement('span');
   element.style.cssText = 'position: fixed; top: -1000px;';
   element.append(document.createTextNode('#'));
@@ -414,20 +362,17 @@ async function copyToClipboard__EXPERIMENTAL(editor, event) {
     const removeListener = editor.registerCommand(lexical.COPY_COMMAND, secondEvent => {
       if (secondEvent instanceof ClipboardEvent) {
         removeListener();
-
         if (clipboardEventTimeout !== null) {
           window.clearTimeout(clipboardEventTimeout);
           clipboardEventTimeout = null;
         }
-
         resolve($copyToClipboardEvent(editor, secondEvent));
-      } // Block the entire copy flow while we wait for the next ClipboardEvent
-
-
+      }
+      // Block the entire copy flow while we wait for the next ClipboardEvent
       return true;
-    }, lexical.COMMAND_PRIORITY_CRITICAL); // If the above hack execCommand hack works, this timeout code should never fire. Otherwise,
+    }, lexical.COMMAND_PRIORITY_CRITICAL);
+    // If the above hack execCommand hack works, this timeout code should never fire. Otherwise,
     // the listener will be quickly freed so that the user can reuse it again
-
     clipboardEventTimeout = window.setTimeout(() => {
       removeListener();
       clipboardEventTimeout = null;
@@ -436,46 +381,37 @@ async function copyToClipboard__EXPERIMENTAL(editor, event) {
     document.execCommand('copy');
     element.remove();
   });
-} // TODO shouldn't pass editor (pass namespace directly)
+}
 
+// TODO shouldn't pass editor (pass namespace directly)
 function $copyToClipboardEvent(editor, event) {
   const domSelection = window.getSelection();
-
   if (!domSelection) {
     return false;
   }
-
   const anchorDOM = domSelection.anchorNode;
   const focusDOM = domSelection.focusNode;
-
   if (anchorDOM !== null && focusDOM !== null && !lexical.isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {
     return false;
   }
-
   event.preventDefault();
   const clipboardData = event.clipboardData;
   const selection = lexical.$getSelection();
-
   if (clipboardData === null || selection === null) {
     return false;
   }
-
   const htmlString = $getHtmlContent(editor);
   const lexicalString = $getLexicalContent(editor);
   let plainString = '';
-
   if (selection !== null) {
     plainString = selection.getTextContent();
   }
-
   if (htmlString !== null) {
     clipboardData.setData('text/html', htmlString);
   }
-
   if (lexicalString !== null) {
     clipboardData.setData('application/x-lexical-editor', lexicalString);
   }
-
   clipboardData.setData('text/plain', plainString);
   return true;
 }

package/package.json

@@ -9,16 +9,16 @@
     "paste"
   ],
   "license": "MIT",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "main": "LexicalClipboard.js",
   "peerDependencies": {
-    "lexical": "0.7.8"
+    "lexical": "0.7.9"
   },
   "dependencies": {
-    "@lexical/utils": "0.7.8",
-    "@lexical/list": "0.7.8",
-    "@lexical/selection": "0.7.8",
-    "@lexical/html": "0.7.8"
+    "@lexical/utils": "0.7.9",
+    "@lexical/list": "0.7.9",
+    "@lexical/selection": "0.7.9",
+    "@lexical/html": "0.7.9"
   },
   "repository": {
     "type": "git",