@lexical/clipboard 0.1.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dominic Gannaway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalClipboard.dev.js

@@ -0,0 +1,420 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 lexical = require('lexical');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function $cloneWithProperties(node) {
+  const latest = node.getLatest();
+  const constructor = latest.constructor;
+  const clone = constructor.clone(latest);
+  clone.__parent = latest.__parent;
+
+  if (lexical.$isElementNode(latest) && lexical.$isElementNode(clone)) {
+    clone.__children = Array.from(latest.__children);
+    clone.__format = latest.__format;
+    clone.__indent = latest.__indent;
+    clone.__dir = latest.__dir;
+  } else if (lexical.$isTextNode(latest) && lexical.$isTextNode(clone)) {
+    clone.__format = latest.__format;
+    clone.__style = latest.__style;
+    clone.__mode = latest.__mode;
+    clone.__detail = latest.__detail;
+  } else if (lexical.$isDecoratorNode(latest) && lexical.$isDecoratorNode(clone)) {
+    clone.__state = latest.__state;
+  } // $FlowFixMe
+
+
+  return clone;
+}
+
+function $getIndexFromPossibleClone(node, parent, nodeMap) {
+  const parentClone = nodeMap.get(parent.getKey());
+
+  if (lexical.$isElementNode(parentClone)) {
+    return parentClone.__children.indexOf(node.getKey());
+  }
+
+  return node.getIndexWithinParent();
+}
+
+function $getParentAvoidingExcludedElements(node) {
+  let parent = node.getParent();
+
+  while (parent !== null && parent.excludeFromCopy()) {
+    parent = parent.getParent();
+  }
+
+  return parent;
+}
+
+function $copyLeafNodeBranchToRoot(leaf, startingOffset, isLeftSide, range, nodeMap) {
+  let node = leaf;
+  let offset = startingOffset;
+
+  while (node !== null) {
+    const parent = $getParentAvoidingExcludedElements(node);
+
+    if (parent === null) {
+      break;
+    }
+
+    if (!lexical.$isElementNode(node) || !node.excludeFromCopy()) {
+      const key = node.getKey();
+      let clone = nodeMap.get(key);
+      const needsClone = clone === undefined;
+
+      if (needsClone) {
+        clone = $cloneWithProperties(node);
+        nodeMap.set(key, clone);
+      }
+
+      if (lexical.$isTextNode(clone) && !clone.isSegmented() && !clone.isToken()) {
+        clone.__text = clone.__text.slice(isLeftSide ? offset : 0, isLeftSide ? undefined : offset);
+      } else if (lexical.$isElementNode(clone)) {
+        clone.__children = clone.__children.slice(isLeftSide ? offset : 0, isLeftSide ? undefined : offset + 1);
+      }
+
+      if (lexical.$isRootNode(parent)) {
+        if (needsClone) {
+          // We only want to collect a range of top level nodes.
+          // So if the parent is the root, we know this is a top level.
+          range.push(key);
+        }
+
+        break;
+      }
+    }
+
+    offset = $getIndexFromPossibleClone(node, parent, nodeMap);
+    node = parent;
+  }
+}
+
+function $cloneContents(selection) {
+  if (!lexical.$isRangeSelection(selection)) {
+    {
+      throw Error(`TODO`);
+    }
+  }
+
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorOffset = anchor.getCharacterOffset();
+  const focusOffset = focus.getCharacterOffset();
+  const anchorNode = anchor.getNode();
+  const focusNode = focus.getNode();
+  const anchorNodeParent = anchorNode.getParentOrThrow(); // Handle a single text node extraction
+
+  if (anchorNode === focusNode && lexical.$isTextNode(anchorNode) && (anchorNodeParent.canBeEmpty() || anchorNodeParent.getChildrenSize() > 1)) {
+    const clonedFirstNode = $cloneWithProperties(anchorNode);
+    const isBefore = focusOffset > anchorOffset;
+    const startOffset = isBefore ? anchorOffset : focusOffset;
+    const endOffset = isBefore ? focusOffset : anchorOffset;
+    clonedFirstNode.__text = clonedFirstNode.__text.slice(startOffset, endOffset);
+    const key = clonedFirstNode.getKey();
+    return {
+      nodeMap: [[key, clonedFirstNode]],
+      range: [key]
+    };
+  }
+
+  const nodes = selection.getNodes();
+
+  if (nodes.length === 0) {
+    return {
+      nodeMap: [],
+      range: []
+    };
+  } // Check if we can use the parent of the nodes, if the
+  // parent can't be empty, then it's important that we
+  // also copy that element node along with its children.
+
+
+  let nodesLength = nodes.length;
+  const firstNode = nodes[0];
+  const firstNodeParent = firstNode.getParent();
+
+  if (firstNodeParent !== null && (!firstNodeParent.canBeEmpty() || lexical.$isRootNode(firstNodeParent))) {
+    const parentChildren = firstNodeParent.__children;
+    const parentChildrenLength = parentChildren.length;
+
+    if (parentChildrenLength === nodesLength) {
+      let areTheSame = true;
+
+      for (let i = 0; i < parentChildren.length; i++) {
+        if (parentChildren[i] !== nodes[i].__key) {
+          areTheSame = false;
+          break;
+        }
+      }
+
+      if (areTheSame) {
+        nodesLength++;
+        nodes.push(firstNodeParent);
+      }
+    }
+  }
+
+  const lastNode = nodes[nodesLength - 1];
+  const isBefore = anchor.isBefore(focus);
+  const nodeMap = new Map();
+  const range = []; // Do first node to root
+
+  $copyLeafNodeBranchToRoot(firstNode, isBefore ? anchorOffset : focusOffset, true, range, nodeMap); // Copy all nodes between
+
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    const key = node.getKey();
+
+    if (!nodeMap.has(key) && (!lexical.$isElementNode(node) || !node.excludeFromCopy())) {
+      const clone = $cloneWithProperties(node);
+
+      if (lexical.$isRootNode(node.getParent())) {
+        range.push(node.getKey());
+      }
+
+      nodeMap.set(key, clone);
+    }
+  } // Do last node to root
+
+
+  $copyLeafNodeBranchToRoot(lastNode, isBefore ? focusOffset : anchorOffset, false, range, nodeMap);
+  return {
+    nodeMap: Array.from(nodeMap.entries()),
+    range
+  };
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function getHtmlContent(editor) {
+  const domSelection = window.getSelection(); // If we haven't selected a range, then don't copy anything
+
+  if (domSelection.isCollapsed) {
+    return null;
+  }
+
+  const range = domSelection.getRangeAt(0);
+
+  if (range) {
+    const container = document.createElement('div');
+    const frag = range.cloneContents();
+    container.appendChild(frag);
+    return container.innerHTML;
+  }
+
+  return null;
+}
+function $getLexicalContent(editor) {
+  const selection = lexical.$getSelection();
+
+  if (selection !== null) {
+    const namespace = editor._config.namespace;
+    return JSON.stringify({
+      namespace,
+      state: $cloneContents(selection)
+    });
+  }
+
+  return null;
+}
+function $insertDataTransferForPlainText(dataTransfer, selection) {
+  const text = dataTransfer.getData('text/plain');
+
+  if (text != null) {
+    selection.insertRawText(text);
+  }
+}
+function $insertDataTransferForRichText(dataTransfer, selection, editor) {
+  const lexicalNodesString = dataTransfer.getData('application/x-lexical-editor');
+
+  if (lexicalNodesString) {
+    const namespace = editor._config.namespace;
+
+    try {
+      const lexicalClipboardData = JSON.parse(lexicalNodesString);
+
+      if (lexicalClipboardData.namespace === namespace) {
+        const nodeRange = lexicalClipboardData.state;
+        const nodes = $generateNodes(nodeRange);
+        selection.insertNodes(nodes);
+        return;
+      }
+    } catch (e) {// Malformed, missing nodes..
+    }
+  }
+
+  const textHtmlMimeType = 'text/html';
+  const htmlString = dataTransfer.getData(textHtmlMimeType);
+
+  if (htmlString) {
+    const parser = new DOMParser();
+    const dom = parser.parseFromString(htmlString, textHtmlMimeType);
+    const nodes = $generateNodesFromDOM(dom, editor); // 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];
+
+      if (!lexical.$isElementNode(node) || node.isInline()) {
+        if (currentBlock === null) {
+          currentBlock = lexical.$createParagraphNode();
+          topLevelBlocks.push(currentBlock);
+        }
+
+        if (currentBlock !== null) {
+          currentBlock.append(node);
+        }
+      } else {
+        topLevelBlocks.push(node);
+        currentBlock = null;
+      }
+    }
+
+    selection.insertNodes(topLevelBlocks);
+    return;
+  }
+
+  $insertDataTransferForPlainText(dataTransfer, selection);
+}
+
+function $generateNodes(nodeRange) {
+  const {
+    range,
+    nodeMap
+  } = nodeRange;
+  const parsedNodeMap = new Map(nodeMap);
+  const nodes = [];
+
+  for (let i = 0; i < range.length; i++) {
+    const key = range[i];
+    const parsedNode = parsedNodeMap.get(key);
+
+    if (parsedNode !== undefined) {
+      const node = lexical.$createNodeFromParse(parsedNode, parsedNodeMap);
+      nodes.push(node);
+    }
+  }
+
+  return nodes;
+}
+
+function getConversionFunction(domNode, editor) {
+  const {
+    nodeName
+  } = domNode;
+
+  const cachedConversions = editor._htmlConversions.get(nodeName.toLowerCase());
+
+  let currentConversion = null;
+
+  if (cachedConversions !== undefined) {
+    cachedConversions.forEach(cachedConversion => {
+      const domConversion = cachedConversion(domNode);
+
+      if (domConversion !== null) {
+        if (currentConversion === null || currentConversion.priority < domConversion.priority) {
+          currentConversion = domConversion;
+        }
+      }
+    });
+  }
+
+  return currentConversion !== null ? currentConversion.conversion : null;
+}
+
+function $createNodesFromDOM(node, editor, forChildMap = new Map()) {
+  let lexicalNodes = [];
+  let currentLexicalNode = null;
+  const transformFunction = getConversionFunction(node, editor);
+  const transformOutput = transformFunction ? transformFunction(node) : null;
+  let postTransform = null;
+
+  if (transformOutput !== null) {
+    postTransform = transformOutput.after;
+    currentLexicalNode = transformOutput.node;
+
+    if (currentLexicalNode !== null) {
+      lexicalNodes.push(currentLexicalNode);
+      const forChildFunctions = Array.from(forChildMap.values());
+
+      for (let i = 0; i < forChildFunctions.length; i++) {
+        forChildFunctions[i](currentLexicalNode);
+      }
+    }
+
+    if (transformOutput.forChild != null) {
+      forChildMap.set(node.nodeName, transformOutput.forChild);
+    }
+  } // If the DOM node doesn't have a transformer, we don't know what
+  // to do with it but we still need to process any childNodes.
+
+
+  const children = node.childNodes;
+  let childLexicalNodes = [];
+
+  for (let i = 0; i < children.length; i++) {
+    childLexicalNodes.push(...$createNodesFromDOM(children[i], editor, forChildMap));
+  }
+
+  if (postTransform != null) {
+    childLexicalNodes = postTransform(childLexicalNodes);
+  }
+
+  if (currentLexicalNode == null) {
+    // If it hasn't been converted to a LexicalNode, we hoist its children
+    // up to the same level as it.
+    lexicalNodes = lexicalNodes.concat(childLexicalNodes);
+  } else {
+    if (lexical.$isElementNode(currentLexicalNode)) {
+      // If the current node is a ElementNode after conversion,
+      // we can append all the children to it.
+      currentLexicalNode.append(...childLexicalNodes);
+    }
+  }
+
+  return lexicalNodes;
+}
+
+function $generateNodesFromDOM(dom, editor) {
+  let lexicalNodes = [];
+  const elements = dom.body ? Array.from(dom.body.childNodes) : [];
+  const elementsLength = elements.length;
+
+  for (let i = 0; i < elementsLength; i++) {
+    const lexicalNode = $createNodesFromDOM(elements[i], editor);
+
+    if (lexicalNode !== null) {
+      lexicalNodes = lexicalNodes.concat(lexicalNode);
+    }
+  }
+
+  return lexicalNodes;
+}
+
+exports.$getLexicalContent = $getLexicalContent;
+exports.$insertDataTransferForPlainText = $insertDataTransferForPlainText;
+exports.$insertDataTransferForRichText = $insertDataTransferForRichText;
+exports.getHtmlContent = getHtmlContent;

package/LexicalClipboard.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalClipboard = process.env.NODE_ENV === 'development' ? require('./LexicalClipboard.dev.js') : require('./LexicalClipboard.prod.js')
+module.exports = LexicalClipboard;

package/LexicalClipboard.prod.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h=require("lexical");function r(a){a=a.getLatest();const b=a.constructor.clone(a);b.__parent=a.__parent;h.$isElementNode(a)&&h.$isElementNode(b)?(b.__children=Array.from(a.__children),b.__format=a.__format,b.__indent=a.__indent,b.__dir=a.__dir):h.$isTextNode(a)&&h.$isTextNode(b)?(b.__format=a.__format,b.__style=a.__style,b.__mode=a.__mode,b.__detail=a.__detail):h.$isDecoratorNode(a)&&h.$isDecoratorNode(b)&&(b.__state=a.__state);return b}
+function t(a,b,l,g,f){for(var c=b;null!==a;){for(b=a.getParent();null!==b&&b.excludeFromCopy();)b=b.getParent();if(null===b)break;if(!h.$isElementNode(a)||!a.excludeFromCopy()){const e=a.getKey();let d=f.get(e);const k=void 0===d;k&&(d=r(a),f.set(e,d));!h.$isTextNode(d)||d.isSegmented()||d.isToken()?h.$isElementNode(d)&&(d.__children=d.__children.slice(l?c:0,l?void 0:c+1)):d.__text=d.__text.slice(l?c:0,l?void 0:c);if(h.$isRootNode(b)){k&&g.push(e);break}}c=f.get(b.getKey());c=h.$isElementNode(c)?
+c.__children.indexOf(a.getKey()):a.getIndexWithinParent();a=b}}function u(a,b){a=a.getData("text/plain");null!=a&&b.insertRawText(a)}function v(a,b){const {nodeName:l}=a;b=b._htmlConversions.get(l.toLowerCase());let g=null;void 0!==b&&b.forEach(f=>{f=f(a);null!==f&&(null===g||g.priority<f.priority)&&(g=f)});return null!==g?g.conversion:null}
+function w(a,b,l=new Map){let g=[],f=null;var c=v(a,b),e=c?c(a):null;c=null;if(null!==e){c=e.after;f=e.node;if(null!==f){g.push(f);var d=Array.from(l.values());for(let k=0;k<d.length;k++)d[k](f)}null!=e.forChild&&l.set(a.nodeName,e.forChild)}a=a.childNodes;e=[];for(d=0;d<a.length;d++)e.push(...w(a[d],b,l));null!=c&&(e=c(e));null==f?g=g.concat(e):h.$isElementNode(f)&&f.append(...e);return g}
+exports.$getLexicalContent=function(a){var b=h.$getSelection();if(null!==b){const x=a._config.namespace;a=JSON;var l=a.stringify;{if(!h.$isRangeSelection(b))throw Error("Minified Lexical error #68; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");var g=b.anchor,f=b.focus;var c=g.getCharacterOffset();const q=f.getCharacterOffset();var e=g.getNode(),d=f.getNode(),k=e.getParentOrThrow();if(e===d&&h.$isTextNode(e)&&(k.canBeEmpty()||
+1<k.getChildrenSize()))b=r(e),e=q>c,b.__text=b.__text.slice(e?c:q,e?q:c),c=b.getKey(),c={nodeMap:[[c,b]],range:[c]};else if(b=b.getNodes(),0===b.length)c={nodeMap:[],range:[]};else{e=b.length;d=b[0];k=d.getParent();if(null!==k&&(!k.canBeEmpty()||h.$isRootNode(k))){var m=k.__children;if(m.length===e){var n=!0;for(var p=0;p<m.length;p++)if(m[p]!==b[p].__key){n=!1;break}n&&(e++,b.push(k))}}k=b[e-1];g=g.isBefore(f);f=new Map;m=[];t(d,g?c:q,!0,m,f);for(d=0;d<e;d++)if(n=b[d],p=n.getKey(),!(f.has(p)||h.$isElementNode(n)&&
+n.excludeFromCopy())){const y=r(n);h.$isRootNode(n.getParent())&&m.push(n.getKey());f.set(p,y)}t(k,g?q:c,!1,m,f);c={nodeMap:Array.from(f.entries()),range:m}}}return l.call(a,{namespace:x,state:c})}return null};exports.$insertDataTransferForPlainText=u;
+exports.$insertDataTransferForRichText=function(a,b,l){var g=a.getData("application/x-lexical-editor");if(g){var f=l._config.namespace;try{const k=JSON.parse(g);if(k.namespace===f){const {range:m,nodeMap:n}=k.state;var c=new Map(n);g=[];for(f=0;f<m.length;f++){var e=c.get(m[f]);if(void 0!==e){var d=h.$createNodeFromParse(e,c);g.push(d)}}b.insertNodes(g);return}}catch(k){}}if(c=a.getData("text/html")){c=(new DOMParser).parseFromString(c,"text/html");a=[];c=c.body?Array.from(c.body.childNodes):[];e=
+c.length;for(d=0;d<e;d++)g=w(c[d],l),null!==g&&(a=a.concat(g));l=a;a=[];c=null;for(e=0;e<l.length;e++)d=l[e],!h.$isElementNode(d)||d.isInline()?(null===c&&(c=h.$createParagraphNode(),a.push(c)),null!==c&&c.append(d)):(a.push(d),c=null);b.insertNodes(a)}else u(a,b)};exports.getHtmlContent=function(){var a=window.getSelection();if(a.isCollapsed)return null;var b=a.getRangeAt(0);return b?(a=document.createElement("div"),b=b.cloneContents(),a.appendChild(b),a.innerHTML):null};

package/README.md

@@ -0,0 +1,3 @@
+# `@lexical/clipboard`
+
+This package contains the functionality for the clipboard feature of Lexical.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@lexical/clipboard",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "description": "This package provides the copy/paste functionality for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "copy",
+    "paste"
+  ],
+  "license": "MIT",
+  "version": "0.1.12",
+  "main": "LexicalClipboard.js",
+  "peerDependencies": {
+    "lexical": "0.1.12",
+    "@lexical/helpers": "0.1.12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-clipboard"
+  }
+}