@lexical/clipboard 0.8.1 → 0.9.1

package/LexicalClipboard.dev.js

@@ -20,75 +20,84 @@ 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
+  return html.$generateHtmlFromNodes(editor, selection);
+} // 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
+  } // 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();
         }
@@ -100,30 +109,36 @@ 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);
       }
@@ -132,25 +147,30 @@ 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();
@@ -158,11 +178,13 @@ 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();
@@ -175,40 +197,51 @@ 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)) {
@@ -222,8 +255,10 @@ 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);
@@ -231,19 +266,20 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
     editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND, undefined);
   }
 }
+
 function exportNodeToJSON(node) {
   const serializedNode = node.exportJSON();
-  const nodeClass = node.constructor;
+  const nodeClass = node.constructor; // @ts-expect-error TODO Replace Class utility type with InstanceType
 
-  // @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)) {
       {
@@ -251,44 +287,50 @@ 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 children = lexical.$isElementNode(target) ? target.getChildren() : [];
+  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)) {
@@ -297,18 +339,21 @@ 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
@@ -316,27 +361,31 @@ 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
+let clipboardEventTimeout = null; // TODO custom selection
 // TODO potentially have a node customizable version for plain text
-async function copyToClipboard__EXPERIMENTAL(editor, event) {
+
+async function copyToClipboard(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(() => {
@@ -344,11 +393,14 @@ 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('#'));
@@ -362,17 +414,20 @@ 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;
@@ -381,37 +436,46 @@ 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;
 }
@@ -423,4 +487,4 @@ exports.$getLexicalContent = $getLexicalContent;
 exports.$insertDataTransferForPlainText = $insertDataTransferForPlainText;
 exports.$insertDataTransferForRichText = $insertDataTransferForRichText;
 exports.$insertGeneratedNodes = $insertGeneratedNodes;
-exports.copyToClipboard__EXPERIMENTAL = copyToClipboard__EXPERIMENTAL;
+exports.copyToClipboard = copyToClipboard;

package/LexicalClipboard.js.flow

@@ -68,7 +68,7 @@ declare export function $generateNodesFromSerializedNodes(
   serializedNodes: Array<BaseSerializedNode>,
 ): Array<LexicalNode>;
 
-declare export function copyToClipboard__EXPERIMENTAL(
+declare export function copyToClipboard(
   editor: LexicalEditor,
   event: null | ClipboardEvent,
 ): Promise<boolean>;

package/LexicalClipboard.prod.js

@@ -17,5 +17,5 @@ function L(a,b){var c=window.getSelection();if(!c)return!1;var f=c.anchorNode;c=
 exports.$generateNodesFromSerializedNodes=J;exports.$getHtmlContent=A;exports.$getLexicalContent=B;exports.$insertDataTransferForPlainText=function(a,b){a=a.getData("text/plain");null!=a&&b.insertRawText(a)};
 exports.$insertDataTransferForRichText=function(a,b,c){var f=a.getData("application/x-lexical-editor");if(f)try{let g=JSON.parse(f);if(g.namespace===c._config.namespace&&Array.isArray(g.nodes)){let h=J(g.nodes);return D(c,h,b)}}catch{}if(f=a.getData("text/html"))try{var e=(new DOMParser).parseFromString(f,"text/html");let g=d.$generateNodesFromDOM(c,e);return D(c,g,b)}catch{}a=a.getData("text/plain");if(null!=a)if(t.$isRangeSelection(b))for(a=a.split(/\r?\n/),c=a.length,e=0;e<c;e++)b.insertText(a[e]),
 e<c-1&&b.insertParagraph();else b.insertRawText(a)};exports.$insertGeneratedNodes=D;
-exports.copyToClipboard__EXPERIMENTAL=async function(a,b){if(null!==K)return!1;if(null!==b)return new Promise(g=>{a.update(()=>{g(L(a,b))})});var c=a.getRootElement();let f=document.getSelection();if(null===c||null===f)return!1;let e=document.createElement("span");e.style.cssText="position: fixed; top: -1000px;";e.append(document.createTextNode("#"));c.append(e);c=new Range;c.setStart(e,0);c.setEnd(e,1);f.removeAllRanges();f.addRange(c);return new Promise(g=>{let h=a.registerCommand(t.COPY_COMMAND,
-k=>{k instanceof ClipboardEvent&&(h(),null!==K&&(window.clearTimeout(K),K=null),g(L(a,k)));return!0},t.COMMAND_PRIORITY_CRITICAL);K=window.setTimeout(()=>{h();K=null;g(!1)},50);document.execCommand("copy");e.remove()})}
+exports.copyToClipboard=async function(a,b){if(null!==K)return!1;if(null!==b)return new Promise(g=>{a.update(()=>{g(L(a,b))})});var c=a.getRootElement();let f=document.getSelection();if(null===c||null===f)return!1;let e=document.createElement("span");e.style.cssText="position: fixed; top: -1000px;";e.append(document.createTextNode("#"));c.append(e);c=new Range;c.setStart(e,0);c.setEnd(e,1);f.removeAllRanges();f.addRange(c);return new Promise(g=>{let h=a.registerCommand(t.COPY_COMMAND,k=>{k instanceof
+ClipboardEvent&&(h(),null!==K&&(window.clearTimeout(K),K=null),g(L(a,k)));return!0},t.COMMAND_PRIORITY_CRITICAL);K=window.setTimeout(()=>{h();K=null;g(!1)},50);document.execCommand("copy");e.remove()})}

package/clipboard.d.ts

@@ -21,4 +21,4 @@ export declare function $generateJSONFromSelectedNodes<SerializedNode extends Ba
     nodes: Array<SerializedNode>;
 };
 export declare function $generateNodesFromSerializedNodes(serializedNodes: Array<BaseSerializedNode>): Array<LexicalNode>;
-export declare function copyToClipboard__EXPERIMENTAL(editor: LexicalEditor, event: null | ClipboardEvent): Promise<boolean>;
+export declare function copyToClipboard(editor: LexicalEditor, event: null | ClipboardEvent): Promise<boolean>;

package/index.d.ts

@@ -6,4 +6,4 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-export { $generateJSONFromSelectedNodes, $generateNodesFromSerializedNodes, $getHtmlContent, $getLexicalContent, $insertDataTransferForPlainText, $insertDataTransferForRichText, $insertGeneratedNodes, copyToClipboard__EXPERIMENTAL, } from './clipboard';
+export { $generateJSONFromSelectedNodes, $generateNodesFromSerializedNodes, $getHtmlContent, $getLexicalContent, $insertDataTransferForPlainText, $insertDataTransferForRichText, $insertGeneratedNodes, copyToClipboard, } from './clipboard';

package/package.json

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