@lexical/clipboard 0.4.1 → 0.5.1-next.0

package/LexicalClipboard.dev.js

@@ -28,11 +28,13 @@ function $getHtmlContent(editor) {
 
 
   if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
-    return null;
+    return '';
   }
 
   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();
 
@@ -101,11 +103,10 @@ function $insertDataTransferForRichText(dataTransfer, selection, editor) {
     }
   }
 }
-
 function $insertGeneratedNodes(editor, nodes, selection) {
-  const isSelectionInsideOfGrid = lexical.$isGridSelection(selection) || utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isGridCellNode(n)) !== null && utils.$findMatchingParent(selection.focus.getNode(), n => lexical.$isGridCellNode(n)) !== null;
+  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.$isGridNode(nodes[0])) {
+  if (isSelectionInsideOfGrid && nodes.length === 1 && lexical.DEPRECATED_$isGridNode(nodes[0])) {
     $mergeGridNodesStrategy(nodes, selection, false, editor);
     return;
   }
@@ -141,10 +142,17 @@ function $basicInsertStrategy(nodes, selection) {
       list$1 = null;
     }
 
-    if (lexical.$isDecoratorNode(node) && !node.isTopLevel() || lexical.$isElementNode(node) && node.isInline() || lexical.$isTextNode(node) || lexical.$isLineBreakNode(node)) {
+    const isLineBreakNode = lexical.$isLineBreakNode(node);
+
+    if (isLineBreakNode || lexical.$isDecoratorNode(node) && node.isInline() || lexical.$isElementNode(node) && node.isInline() || lexical.$isTextNode(node)) {
       if (currentBlock === null) {
         currentBlock = lexical.$createParagraphNode();
-        topLevelBlocks.push(currentBlock);
+        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) {
@@ -158,11 +166,11 @@ function $basicInsertStrategy(nodes, selection) {
 
   if (lexical.$isRangeSelection(selection)) {
     selection.insertNodes(topLevelBlocks);
-  } else if (lexical.$isGridSelection(selection)) {
+  } 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.$isGridCellNode(anchorCell)) {
+    if (!lexical.DEPRECATED_$isGridCellNode(anchorCell)) {
       {
         throw Error(`Expected Grid Cell in Grid Selection`);
       }
@@ -173,7 +181,7 @@ function $basicInsertStrategy(nodes, selection) {
 }
 
 function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
-  if (nodes.length !== 1 || !lexical.$isGridNode(nodes[0])) {
+  if (nodes.length !== 1 || !lexical.DEPRECATED_$isGridNode(nodes[0])) {
     {
       throw Error(`$mergeGridNodesStrategy: Expected Grid insertion.`);
     }
@@ -183,11 +191,11 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   const newGridRows = newGrid.getChildren();
   const newColumnCount = newGrid.getFirstChildOrThrow().getChildrenSize();
   const newRowCount = newGrid.getChildrenSize();
-  const gridCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isGridCellNode(n));
-  const gridRowNode = gridCellNode && utils.$findMatchingParent(gridCellNode, n => lexical.$isGridRowNode(n));
-  const gridNode = gridRowNode && utils.$findMatchingParent(gridRowNode, n => lexical.$isGridNode(n));
+  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.$isGridCellNode(gridCellNode) || !lexical.$isGridRowNode(gridRowNode) || !lexical.$isGridNode(gridNode)) {
+  if (!lexical.DEPRECATED_$isGridCellNode(gridCellNode) || !lexical.DEPRECATED_$isGridRowNode(gridRowNode) || !lexical.DEPRECATED_$isGridNode(gridNode)) {
     {
       throw Error(`$mergeGridNodesStrategy: Expected selection to be inside of a Grid.`);
     }
@@ -209,7 +217,7 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   for (let r = fromY; r <= toY; r++) {
     const currentGridRowNode = gridRowNodes[r];
 
-    if (!lexical.$isGridRowNode(currentGridRowNode)) {
+    if (!lexical.DEPRECATED_$isGridRowNode(currentGridRowNode)) {
       {
         throw Error(`getNodes: expected to find GridRowNode`);
       }
@@ -217,7 +225,7 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
 
     const newGridRowNode = newGridRows[newRowIdx];
 
-    if (!lexical.$isGridRowNode(newGridRowNode)) {
+    if (!lexical.DEPRECATED_$isGridRowNode(newGridRowNode)) {
       {
         throw Error(`getNodes: expected to find GridRowNode`);
       }
@@ -230,7 +238,7 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
     for (let c = fromX; c <= toX; c++) {
       const currentGridCellNode = gridCellNodes[c];
 
-      if (!lexical.$isGridCellNode(currentGridCellNode)) {
+      if (!lexical.DEPRECATED_$isGridCellNode(currentGridCellNode)) {
         {
           throw Error(`getNodes: expected to find GridCellNode`);
         }
@@ -238,7 +246,7 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
 
       const newGridCellNode = newGridCellNodes[newColumnIdx];
 
-      if (!lexical.$isGridCellNode(newGridCellNode)) {
+      if (!lexical.DEPRECATED_$isGridCellNode(newGridCellNode)) {
         {
           throw Error(`getNodes: expected to find GridCellNode`);
         }
@@ -268,7 +276,7 @@ function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
   }
 
   if (newAnchorCellKey && newFocusCellKey) {
-    const newGridSelection = lexical.$createGridSelection();
+    const newGridSelection = lexical.DEPRECATED_$createGridSelection();
     newGridSelection.set(gridNode.getKey(), newAnchorCellKey, newFocusCellKey);
     lexical.$setSelection(newGridSelection);
     editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND, undefined);
@@ -302,18 +310,24 @@ function exportNodeToJSON(node) {
 function $appendNodesToJSON(editor, selection$1, currentNode, targetArray = []) {
   let shouldInclude = selection$1 != null ? currentNode.isSelected() : true;
   const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('html');
-  let clone = selection.$cloneWithProperties(currentNode);
-  clone = lexical.$isTextNode(clone) && selection$1 != null ? selection.$sliceSelectedTextNodeContent(selection$1, clone) : clone;
-  const children = lexical.$isElementNode(clone) ? clone.getChildren() : [];
-  const serializedNode = exportNodeToJSON(clone); // TODO: TextNode calls getTextContent() (NOT node.__text) within it's exportJSON method
+  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
   // 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(clone)) {
-    serializedNode.text = clone.__text;
+  if (lexical.$isTextNode(target)) {
+    serializedNode.text = target.__text;
   }
 
   for (let i = 0; i < children.length; i++) {
@@ -335,7 +349,8 @@ function $appendNodesToJSON(editor, selection$1, currentNode, targetArray = [])
   }
 
   return shouldInclude;
-}
+} // TODO why $ function with Editor instance?
+
 
 function $generateJSONFromSelectedNodes(editor, selection) {
   const nodes = [];
@@ -368,8 +383,103 @@ function $generateNodesFromSerializedNodes(serializedNodes) {
 
   return nodes;
 }
+const EVENT_LATENCY = 50;
+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(() => {
+        resolve($copyToClipboardEvent(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('#'));
+  rootElement.append(element);
+  const range = new Range();
+  range.setStart(element, 0);
+  range.setEnd(element, 1);
+  domSelection.removeAllRanges();
+  domSelection.addRange(range);
+  return new Promise((resolve, reject) => {
+    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
+
+
+      return true;
+    }, 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;
+      resolve(false);
+    }, EVENT_LATENCY);
+    document.execCommand('copy');
+    element.remove();
+  });
+} // TODO shouldn't pass editor (pass namespace directly)
+
+function $copyToClipboardEvent(editor, event) {
+  event.preventDefault();
+  const clipboardData = event.clipboardData;
+
+  if (clipboardData === null) {
+    return false;
+  }
+
+  const selection = lexical.$getSelection();
+  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;
+}
 
+exports.$generateJSONFromSelectedNodes = $generateJSONFromSelectedNodes;
+exports.$generateNodesFromSerializedNodes = $generateNodesFromSerializedNodes;
 exports.$getHtmlContent = $getHtmlContent;
 exports.$getLexicalContent = $getLexicalContent;
 exports.$insertDataTransferForPlainText = $insertDataTransferForPlainText;
 exports.$insertDataTransferForRichText = $insertDataTransferForRichText;
+exports.$insertGeneratedNodes = $insertGeneratedNodes;
+exports.copyToClipboard__EXPERIMENTAL = copyToClipboard__EXPERIMENTAL;

package/LexicalClipboard.js.flow

@@ -29,6 +29,12 @@ declare export function $getHtmlContent(editor: LexicalEditor): string | null;
 declare export function $getLexicalContent(
   editor: LexicalEditor,
 ): string | null;
+
+declare export function $insertGeneratedNodes(
+  editor: LexicalEditor,
+  nodes: Array<LexicalNode>,
+  selection: RangeSelection | GridSelection,
+): void;
 /*
  * Plain Text
  */
@@ -61,3 +67,8 @@ declare export function $generateJSONFromSelectedNodes<
 declare export function $generateNodesFromSerializedNodes(
   serializedNodes: Array<BaseSerializedNode>,
 ): Array<LexicalNode>;
+
+declare export function copyToClipboard__EXPERIMENTAL(
+  editor: LexicalEditor,
+  event: null | ClipboardEvent,
+): Promise<boolean>;

package/LexicalClipboard.prod.js

@@ -4,15 +4,19 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-'use strict';var d=require("@lexical/html"),p=require("@lexical/list"),r=require("@lexical/selection"),y=require("@lexical/utils"),z=require("lexical");function A(a){throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?code=${a} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-function B(a,c,e){(z.$isGridSelection(e)||null!==y.$findMatchingParent(e.anchor.getNode(),g=>z.$isGridCellNode(g))&&null!==y.$findMatchingParent(e.focus.getNode(),g=>z.$isGridCellNode(g)))&&1===c.length&&z.$isGridNode(c[0])?E(c,e,!1,a):F(c,e)}
-function F(a,c){let e=[],g=null,f=null;for(let h=0;h<a.length;h++){let b=a[h];p.$isListItemNode(b)?(null==f&&(f=p.$createListNode("bullet"),e.push(f)),f.append(b)):(null!=f&&(f=null),z.$isDecoratorNode(b)&&!b.isTopLevel()||z.$isElementNode(b)&&b.isInline()||z.$isTextNode(b)||z.$isLineBreakNode(b)?(null===g&&(g=z.$createParagraphNode(),e.push(g)),null!==g&&g.append(b)):(e.push(b),g=null))}z.$isRangeSelection(c)?c.insertNodes(e):z.$isGridSelection(c)&&(a=c.anchor.getNode(),z.$isGridCellNode(a)||A(41),
-a.append(...e))}
-function E(a,c,e,g){1===a.length&&z.$isGridNode(a[0])||A(42);var f=a[0];a=f.getChildren();e=f.getFirstChildOrThrow().getChildrenSize();var h=f.getChildrenSize(),b=y.$findMatchingParent(c.anchor.getNode(),m=>z.$isGridCellNode(m));c=(f=b&&y.$findMatchingParent(b,m=>z.$isGridRowNode(m)))&&y.$findMatchingParent(f,m=>z.$isGridNode(m));z.$isGridCellNode(b)&&z.$isGridRowNode(f)&&z.$isGridNode(c)||A(43);var k=f.getIndexWithinParent(),n=Math.min(c.getChildrenSize()-1,k+h-1);h=b.getIndexWithinParent();b=Math.min(f.getChildrenSize()-
-1,h+e-1);e=Math.min(h,b);f=Math.min(k,n);h=Math.max(h,b);k=Math.max(k,n);n=c.getChildren();b=0;let l,q;for(let m=f;m<=k;m++){var w=n[m];z.$isGridRowNode(w)||A(24);var x=a[b];z.$isGridRowNode(x)||A(24);w=w.getChildren();x=x.getChildren();let C=0;for(let t=e;t<=h;t++){let u=w[t];z.$isGridCellNode(u)||A(25);let D=x[C];z.$isGridCellNode(D)||A(25);m===f&&t===e?l=u.getKey():m===k&&t===h&&(q=u.getKey());let H=u.getChildren();D.getChildren().forEach(v=>{z.$isTextNode(v)&&z.$createParagraphNode().append(v);
-u.append(v)});H.forEach(v=>v.remove());C++}b++}l&&q&&(a=z.$createGridSelection(),a.set(c.getKey(),l,q),z.$setSelection(a),g.dispatchCommand(z.SELECTION_CHANGE_COMMAND,void 0))}
-function G(a,c,e,g=[]){let f=null!=c?e.isSelected():!0,h=z.$isElementNode(e)&&e.excludeFromCopy("html");var b=r.$cloneWithProperties(e);b=z.$isTextNode(b)&&null!=c?r.$sliceSelectedTextNodeContent(c,b):b;let k=z.$isElementNode(b)?b.getChildren():[];var n=b;let l=n.exportJSON();l.type!==n.constructor.getType()&&A(58);var q=l.children;z.$isElementNode(n)&&(Array.isArray(q)||A(59));z.$isTextNode(b)&&(l.text=b.__text);for(b=0;b<k.length;b++)n=k[b],q=G(a,c,n,l.children),!f&&z.$isElementNode(e)&&q&&e.extractWithChild(n,
-c,"clone")&&(f=!0);if(f&&!h)g.push(l);else if(Array.isArray(l.children))for(a=0;a<l.children.length;a++)g.push(l.children[a]);return f}exports.$getHtmlContent=function(a){let c=z.$getSelection();if(null==c)throw Error("Expected valid LexicalSelection");return z.$isRangeSelection(c)&&c.isCollapsed()||0===c.getNodes().length?null:d.$generateHtmlFromNodes(a,c)};
-exports.$getLexicalContent=function(a){let c=z.$getSelection();if(null==c)throw Error("Expected valid LexicalSelection");if(z.$isRangeSelection(c)&&c.isCollapsed()||0===c.getNodes().length)return null;var e=JSON,g=e.stringify;let f=[],h=z.$getRoot().getChildren();for(let b=0;b<h.length;b++)G(a,c,h[b],f);return g.call(e,{namespace:a._config.namespace,nodes:f})};exports.$insertDataTransferForPlainText=function(a,c){a=a.getData("text/plain");null!=a&&c.insertRawText(a)};
-exports.$insertDataTransferForRichText=function(a,c,e){var g=a.getData("application/x-lexical-editor");if(g)try{var f=JSON.parse(g);if(f.namespace===e._config.namespace&&Array.isArray(f.nodes)){var h=f.nodes;g=[];for(f=0;f<h.length;f++){let k=z.$parseSerializedNode(h[f]);z.$isTextNode(k)&&r.$addNodeStyle(k);g.push(k)}return B(e,g,c)}}catch{}if(h=a.getData("text/html"))try{var b=(new DOMParser).parseFromString(h,"text/html");let k=d.$generateNodesFromDOM(e,b);return B(e,k,c)}catch{}a=a.getData("text/plain");
-if(null!=a)if(z.$isRangeSelection(c))for(a=a.split(/\r?\n/),e=a.length,b=0;b<e;b++)c.insertText(a[b]),b<e-1&&c.insertParagraph();else c.insertRawText(a)}
+'use strict';var d=require("@lexical/html"),n=require("@lexical/list"),r=require("@lexical/selection"),t=require("@lexical/utils"),z=require("lexical");function A(a){throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?code=${a} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
+function B(a){let b=z.$getSelection();if(null==b)throw Error("Expected valid LexicalSelection");return z.$isRangeSelection(b)&&b.isCollapsed()||0===b.getNodes().length?"":d.$generateHtmlFromNodes(a,b)}function C(a){let b=z.$getSelection();if(null==b)throw Error("Expected valid LexicalSelection");return z.$isRangeSelection(b)&&b.isCollapsed()||0===b.getNodes().length?null:JSON.stringify(D(a,b))}
+function E(a,b,c){(z.DEPRECATED_$isGridSelection(c)||null!==t.$findMatchingParent(c.anchor.getNode(),g=>z.DEPRECATED_$isGridCellNode(g))&&null!==t.$findMatchingParent(c.focus.getNode(),g=>z.DEPRECATED_$isGridCellNode(g)))&&1===b.length&&z.DEPRECATED_$isGridNode(b[0])?F(b,c,!1,a):I(b,c)}
+function I(a,b){let c=[],g=null,e=null;for(let k=0;k<a.length;k++){let f=a[k];if(n.$isListItemNode(f)){null==e&&(e=n.$createListNode("bullet"),c.push(e));e.append(f);continue}else null!=e&&(e=null);let h=z.$isLineBreakNode(f);if(h||z.$isDecoratorNode(f)&&f.isInline()||z.$isElementNode(f)&&f.isInline()||z.$isTextNode(f)){if(null===g&&(g=z.$createParagraphNode(),c.push(g),h))continue;null!==g&&g.append(f)}else c.push(f),g=null}z.$isRangeSelection(b)?b.insertNodes(c):z.DEPRECATED_$isGridSelection(b)&&
+(a=b.anchor.getNode(),z.DEPRECATED_$isGridCellNode(a)||A(41),a.append(...c))}
+function F(a,b,c,g){1===a.length&&z.DEPRECATED_$isGridNode(a[0])||A(42);var e=a[0];a=e.getChildren();c=e.getFirstChildOrThrow().getChildrenSize();var k=e.getChildrenSize(),f=t.$findMatchingParent(b.anchor.getNode(),l=>z.DEPRECATED_$isGridCellNode(l));b=(e=f&&t.$findMatchingParent(f,l=>z.DEPRECATED_$isGridRowNode(l)))&&t.$findMatchingParent(e,l=>z.DEPRECATED_$isGridNode(l));z.DEPRECATED_$isGridCellNode(f)&&z.DEPRECATED_$isGridRowNode(e)&&z.DEPRECATED_$isGridNode(b)||A(43);var h=e.getIndexWithinParent(),
+p=Math.min(b.getChildrenSize()-1,h+k-1);k=f.getIndexWithinParent();f=Math.min(e.getChildrenSize()-1,k+c-1);c=Math.min(k,f);e=Math.min(h,p);k=Math.max(k,f);h=Math.max(h,p);p=b.getChildren();f=0;let m,q;for(let l=e;l<=h;l++){var x=p[l];z.DEPRECATED_$isGridRowNode(x)||A(24);var y=a[f];z.DEPRECATED_$isGridRowNode(y)||A(24);x=x.getChildren();y=y.getChildren();let G=0;for(let u=c;u<=k;u++){let v=x[u];z.DEPRECATED_$isGridCellNode(v)||A(25);let H=y[G];z.DEPRECATED_$isGridCellNode(H)||A(25);l===e&&u===c?m=
+v.getKey():l===h&&u===k&&(q=v.getKey());let N=v.getChildren();H.getChildren().forEach(w=>{z.$isTextNode(w)&&z.$createParagraphNode().append(w);v.append(w)});N.forEach(w=>w.remove());G++}f++}m&&q&&(a=z.DEPRECATED_$createGridSelection(),a.set(b.getKey(),m,q),z.$setSelection(a),g.dispatchCommand(z.SELECTION_CHANGE_COMMAND,void 0))}
+function J(a,b,c,g=[]){let e=null!=b?c.isSelected():!0,k=z.$isElementNode(c)&&c.excludeFromCopy("html");var f=c;if(null!==b){var h=r.$cloneWithProperties(c);f=h=z.$isTextNode(h)&&null!=b?r.$sliceSelectedTextNodeContent(b,h):h}let p=z.$isElementNode(f)?f.getChildren():[];var m=f;h=m.exportJSON();h.type!==m.constructor.getType()&&A(58);var q=h.children;z.$isElementNode(m)&&(Array.isArray(q)||A(59));z.$isTextNode(f)&&(h.text=f.__text);for(f=0;f<p.length;f++)m=p[f],q=J(a,b,m,h.children),!e&&z.$isElementNode(c)&&
+q&&c.extractWithChild(m,b,"clone")&&(e=!0);if(e&&!k)g.push(h);else if(Array.isArray(h.children))for(a=0;a<h.children.length;a++)g.push(h.children[a]);return e}function D(a,b){let c=[],g=z.$getRoot().getChildren();for(let e=0;e<g.length;e++)J(a,b,g[e],c);return{namespace:a._config.namespace,nodes:c}}function K(a){let b=[];for(let c=0;c<a.length;c++){let g=z.$parseSerializedNode(a[c]);z.$isTextNode(g)&&r.$addNodeStyle(g);b.push(g)}return b}let L=null;
+function M(a,b){b.preventDefault();b=b.clipboardData;if(null===b)return!1;let c=z.$getSelection(),g=B(a);a=C(a);let e="";null!==c&&(e=c.getTextContent());null!==g&&b.setData("text/html",g);null!==a&&b.setData("application/x-lexical-editor",a);b.setData("text/plain",e);return!0}exports.$generateJSONFromSelectedNodes=D;exports.$generateNodesFromSerializedNodes=K;exports.$getHtmlContent=B;exports.$getLexicalContent=C;
+exports.$insertDataTransferForPlainText=function(a,b){a=a.getData("text/plain");null!=a&&b.insertRawText(a)};
+exports.$insertDataTransferForRichText=function(a,b,c){var g=a.getData("application/x-lexical-editor");if(g)try{let k=JSON.parse(g);if(k.namespace===c._config.namespace&&Array.isArray(k.nodes)){let f=K(k.nodes);return E(c,f,b)}}catch{}if(g=a.getData("text/html"))try{var e=(new DOMParser).parseFromString(g,"text/html");let k=d.$generateNodesFromDOM(c,e);return E(c,k,b)}catch{}a=a.getData("text/plain");if(null!=a)if(z.$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=E;
+exports.copyToClipboard__EXPERIMENTAL=async function(a,b){if(null!==L)return!1;if(null!==b)return new Promise(k=>{a.update(()=>{k(M(a,b))})});var c=a.getRootElement();let g=document.getSelection();if(null===c||null===g)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);g.removeAllRanges();g.addRange(c);return new Promise(k=>{let f=a.registerCommand(z.COPY_COMMAND,
+h=>{h instanceof ClipboardEvent&&(f(),null!==L&&(window.clearTimeout(L),L=null),k(M(a,h)));return!0},z.COMMAND_PRIORITY_CRITICAL);L=window.setTimeout(()=>{f();L=null;k(!1)},50);document.execCommand("copy");e.remove()})}

package/clipboard.d.ts

@@ -5,12 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { GridSelection, LexicalEditor, LexicalNode, NodeSelection, RangeSelection } from 'lexical';
-export declare function $getHtmlContent(editor: LexicalEditor): string | null;
-export declare function $getLexicalContent(editor: LexicalEditor): string | null;
+import { GridSelection, LexicalEditor, LexicalNode, NodeSelection, RangeSelection } from 'lexical';
+export declare function $getHtmlContent(editor: LexicalEditor): string;
+export declare function $getLexicalContent(editor: LexicalEditor): null | string;
 export declare function $insertDataTransferForPlainText(dataTransfer: DataTransfer, selection: RangeSelection | GridSelection): void;
 export declare function $insertDataTransferForRichText(dataTransfer: DataTransfer, selection: RangeSelection | GridSelection, editor: LexicalEditor): void;
-interface BaseSerializedNode {
+export declare function $insertGeneratedNodes(editor: LexicalEditor, nodes: Array<LexicalNode>, selection: RangeSelection | GridSelection): void;
+export interface BaseSerializedNode {
     children?: Array<BaseSerializedNode>;
     type: string;
     version: number;
@@ -20,4 +21,4 @@ export declare function $generateJSONFromSelectedNodes<SerializedNode extends Ba
     nodes: Array<SerializedNode>;
 };
 export declare function $generateNodesFromSerializedNodes(serializedNodes: Array<BaseSerializedNode>): Array<LexicalNode>;
-export {};
+export declare function copyToClipboard__EXPERIMENTAL(editor: LexicalEditor, event: null | ClipboardEvent): Promise<boolean>;

package/index.d.ts

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

package/package.json

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