@lexical/react 0.1.7 → 0.1.8

package/LexicalHistoryPlugin.dev.js

@@ -0,0 +1,344 @@
+/**
+ * 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 LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var withSubscriptions = require('@lexical/react/withSubscriptions');
+var lexical = require('lexical');
+var react = require('react');
+
+/**
+ * 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.
+ *
+ * 
+ */
+const MERGE = 0;
+const NO_MERGE = 1;
+const DISCARD = 2;
+const OTHER = 0;
+const COMPOSING_CHARACTER = 1;
+const INSERT_CHARACTER_AFTER_SELECTION = 2;
+const DELETE_CHARACTER_BEFORE_SELECTION = 3;
+const DELETE_CHARACTER_AFTER_SELECTION = 4;
+const EditorPriority = 0;
+
+function getDirtyNodes(editorState, dirtyLeavesSet, dirtyElementsSet) {
+  const dirtyLeaves = Array.from(dirtyLeavesSet);
+  const dirtyElements = Array.from(dirtyElementsSet);
+  const nodeMap = editorState._nodeMap;
+  const nodes = [];
+
+  for (let i = 0; i < dirtyLeaves.length; i++) {
+    const dirtyLeafKey = dirtyLeaves[i];
+    const dirtyLeaf = nodeMap.get(dirtyLeafKey);
+
+    if (dirtyLeaf !== undefined) {
+      nodes.push(dirtyLeaf);
+    }
+  }
+
+  for (let i = 0; i < dirtyElements.length; i++) {
+    const intentionallyMarkedAsDirty = dirtyElements[i][1];
+
+    if (!intentionallyMarkedAsDirty) {
+      continue;
+    }
+
+    const dirtyElementKey = dirtyElements[i][0];
+    const dirtyElement = nodeMap.get(dirtyElementKey);
+
+    if (dirtyElement !== undefined && !lexical.$isRootNode(dirtyElement)) {
+      nodes.push(dirtyElement);
+    }
+  }
+
+  return nodes;
+}
+
+function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
+  if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0) {
+    return OTHER;
+  }
+
+  const nextSelection = nextEditorState._selection;
+  const prevSelection = prevEditorState._selection;
+
+  if (isComposing) {
+    return COMPOSING_CHARACTER;
+  }
+
+  if (nextSelection === null || prevSelection === null || !prevSelection.isCollapsed() || !nextSelection.isCollapsed()) {
+    return OTHER;
+  }
+
+  const dirtyNodes = getDirtyNodes(nextEditorState, dirtyLeavesSet, dirtyElementsSet);
+
+  if (dirtyNodes.length === 0) {
+    return OTHER;
+  } // Catching the case when inserting new text node into an element (e.g. first char in paragraph/list),
+  // or after existing node.
+
+
+  if (dirtyNodes.length > 1) {
+    const nextNodeMap = nextEditorState._nodeMap;
+    const nextAnchorNode = nextNodeMap.get(nextSelection.anchor.key);
+    const prevAnchorNode = nextNodeMap.get(prevSelection.anchor.key);
+
+    if (nextAnchorNode && prevAnchorNode && !prevEditorState._nodeMap.has(nextAnchorNode.__key) && lexical.$isTextNode(nextAnchorNode) && nextAnchorNode.__text.length === 1 && nextSelection.anchor.offset === 1) {
+      return INSERT_CHARACTER_AFTER_SELECTION;
+    }
+
+    return OTHER;
+  }
+
+  const nextDirtyNode = dirtyNodes[0];
+
+  const prevDirtyNode = prevEditorState._nodeMap.get(nextDirtyNode.__key);
+
+  if (!lexical.$isTextNode(prevDirtyNode) || !lexical.$isTextNode(nextDirtyNode) || prevDirtyNode.__mode !== nextDirtyNode.__mode) {
+    return OTHER;
+  }
+
+  const prevText = prevDirtyNode.__text;
+  const nextText = nextDirtyNode.__text;
+
+  if (prevText === nextText) {
+    return OTHER;
+  }
+
+  const nextAnchor = nextSelection.anchor;
+  const prevAnchor = prevSelection.anchor;
+
+  if (nextAnchor.key !== prevAnchor.key || nextAnchor.type !== 'text') {
+    return OTHER;
+  }
+
+  const nextAnchorOffset = nextAnchor.offset;
+  const prevAnchorOffset = prevAnchor.offset;
+  const textDiff = nextText.length - prevText.length;
+
+  if (textDiff === 1 && prevAnchorOffset === nextAnchorOffset - 1) {
+    return INSERT_CHARACTER_AFTER_SELECTION;
+  }
+
+  if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset + 1) {
+    return DELETE_CHARACTER_BEFORE_SELECTION;
+  }
+
+  if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset) {
+    return DELETE_CHARACTER_AFTER_SELECTION;
+  }
+
+  return OTHER;
+}
+
+function createMergeActionGetter(editor, delay) {
+  let prevChangeTime = Date.now();
+  let prevChangeType = OTHER;
+  return (prevEditorState, nextEditorState, currentHistoryEntry, dirtyLeaves, dirtyElements, tags) => {
+    const changeTime = Date.now(); // If applying changes from history stack there's no need
+    // to run history logic again, as history entries already calculated
+
+    if (tags.has('historic')) {
+      prevChangeType = OTHER;
+      prevChangeTime = changeTime;
+      return DISCARD;
+    }
+
+    const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
+
+    const mergeAction = (() => {
+      if (tags.has('without-history')) {
+        return MERGE;
+      }
+
+      if (prevEditorState === null) {
+        return NO_MERGE;
+      }
+
+      const selection = nextEditorState._selection;
+      const prevSelection = prevEditorState._selection;
+      const hasDirtyNodes = dirtyLeaves.size > 0 || dirtyElements.size > 0;
+
+      if (!hasDirtyNodes) {
+        if (prevSelection === null && selection !== null) {
+          return MERGE;
+        }
+
+        return DISCARD;
+      }
+
+      const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
+
+      if (changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
+        return MERGE;
+      }
+
+      return NO_MERGE;
+    })();
+
+    prevChangeTime = changeTime;
+    prevChangeType = changeType;
+    return mergeAction;
+  };
+}
+
+function useHistory(editor, externalHistoryState, delay = 1000) {
+  const historyState = react.useMemo(() => externalHistoryState || createEmptyHistoryState(), [externalHistoryState]);
+  const clearHistory = react.useCallback(() => {
+    historyState.undoStack = [];
+    historyState.redoStack = [];
+    historyState.current = null;
+  }, [historyState]);
+  react.useEffect(() => {
+    const getMergeAction = createMergeActionGetter(editor, delay);
+
+    const applyChange = ({
+      editorState,
+      prevEditorState,
+      dirtyLeaves,
+      dirtyElements,
+      tags
+    }) => {
+      const current = historyState.current;
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+      const currentEditorState = current === null ? null : current.editorState;
+
+      if (current !== null && editorState === currentEditorState) {
+        return;
+      }
+
+      const mergeAction = getMergeAction(prevEditorState, editorState, current, dirtyLeaves, dirtyElements, tags);
+
+      if (mergeAction === NO_MERGE) {
+        if (redoStack.length !== 0) {
+          historyState.redoStack = [];
+        }
+
+        if (current !== null) {
+          undoStack.push({ ...current,
+            undoSelection: prevEditorState.read(lexical.$getSelection)
+          });
+          editor.execCommand('canUndo', true);
+        }
+      } else if (mergeAction === DISCARD) {
+        return;
+      } // Else we merge
+
+
+      historyState.current = {
+        editor,
+        editorState
+      };
+    };
+
+    const undo = () => {
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+      const undoStackLength = undoStack.length;
+
+      if (undoStackLength !== 0) {
+        const current = historyState.current;
+        const historyStateEntry = undoStack.pop();
+
+        if (current !== null) {
+          redoStack.push(current);
+          editor.execCommand('canRedo', true);
+        }
+
+        if (undoStack.length === 0) {
+          editor.execCommand('canUndo', false);
+        }
+
+        historyState.current = historyStateEntry;
+        historyStateEntry.editor.setEditorState(historyStateEntry.editorState.clone(historyStateEntry.undoSelection), {
+          tag: 'historic'
+        });
+      }
+    };
+
+    const redo = () => {
+      const redoStack = historyState.redoStack;
+      const undoStack = historyState.undoStack;
+
+      if (redoStack.length !== 0) {
+        const current = historyState.current;
+
+        if (current !== null) {
+          undoStack.push(current);
+          editor.execCommand('canUndo', true);
+        }
+
+        const historyStateEntry = redoStack.pop();
+
+        if (redoStack.length === 0) {
+          editor.execCommand('canRedo', false);
+        }
+
+        historyState.current = historyStateEntry;
+        historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
+          tag: 'historic'
+        });
+      }
+    };
+
+    const applyCommand = type => {
+      switch (type) {
+        case 'undo':
+          undo();
+          return true;
+
+        case 'redo':
+          redo();
+          return true;
+
+        case 'clearEditor':
+          clearHistory();
+          return false;
+
+        case 'clearHistory':
+          clearHistory();
+          return true;
+
+        default:
+          return false;
+      }
+    };
+
+    return withSubscriptions(editor.addListener('command', applyCommand, EditorPriority), editor.addListener('update', applyChange));
+  }, [clearHistory, delay, editor, historyState]);
+}
+function createEmptyHistoryState() {
+  return {
+    current: null,
+    redoStack: [],
+    undoStack: []
+  };
+}
+
+/**
+ * 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 HistoryPlugin({
+  externalHistoryState
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  useHistory(editor, externalHistoryState);
+  return null;
+}
+
+exports.HistoryPlugin = HistoryPlugin;
+exports.createEmptyHistoryState = createEmptyHistoryState;

package/LexicalHistoryPlugin.js

@@ -1,7 +1,9 @@
-'use strict';var n=require("@lexical/react/LexicalComposerContext"),r=require("lexical"),v=require("react"),w=require("@lexical/react/withSubscriptions");
-function x(b,d,k,a,h){if(null===b||0===k.size&&0===a.size)return 0;var g=d._selection,c=b._selection;if(h)return 1;if(null===g||null===c||!c.isCollapsed()||!g.isCollapsed())return 0;var e=Array.from(k);a=Array.from(a);k=d._nodeMap;h=[];for(var f=0;f<e.length;f++){const l=k.get(e[f]);void 0!==l&&h.push(l)}for(e=0;e<a.length;e++)a[e][1]&&(f=k.get(a[e][0]),void 0===f||r.$isRootNode(f)||h.push(f));if(0===h.length)return 0;if(1<h.length)return a=d._nodeMap,d=a.get(g.anchor.key),c=a.get(c.anchor.key),d&&
-c&&!b._nodeMap.has(d.__key)&&r.$isTextNode(d)&&1===d.__text.length&&1===g.anchor.offset?2:0;d=h[0];b=b._nodeMap.get(d.__key);if(!r.$isTextNode(b)||!r.$isTextNode(d)||b.__mode!==d.__mode)return 0;b=b.__text;d=d.__text;if(b===d)return 0;g=g.anchor;c=c.anchor;if(g.key!==c.key||"text"!==g.type)return 0;g=g.offset;c=c.offset;b=d.length-b.length;return 1===b&&c===g-1?2:-1===b&&c===g+1?3:-1===b&&c===g?4:0}
-function y(b,d){let k=Date.now(),a=0;return(h,g,c,e,f,l)=>{const p=Date.now();if(l.has("historic"))return a=0,k=p,2;const m=x(h,g,e,f,b.isComposing()),u=(()=>{if(l.has("without-history"))return 0;if(null===h)return 1;var q=g._selection;const t=h._selection;if(!(0<e.size||0<f.size))return null===t&&null!==q?0:2;q=null===c||c.editor===b;return 0!==m&&m===a&&p<k+d&&q?0:1})();k=p;a=m;return u}}
-function z(b,d,k=1E3){const a=v.useMemo(()=>d||A(),[d]),h=v.useCallback(()=>{a.undoStack=[];a.redoStack=[];a.current=null},[a]);v.useEffect(()=>{const g=y(b,k);return w(b.addListener("command",c=>{switch(c){case "undo":c=a.redoStack;var e=a.undoStack;if(0!==e.length){var f=a.current;const l=e.pop();null!==f&&(c.push(f),b.execCommand("canRedo",!0));0===e.length&&b.execCommand("canUndo",!1);a.current=l;l.editor.setEditorState(l.editorState.clone(l.undoSelection),{tag:"historic"})}return!0;case "redo":return c=
-a.redoStack,e=a.undoStack,0!==c.length&&(f=a.current,null!==f&&(e.push(f),b.execCommand("canUndo",!0)),e=c.pop(),0===c.length&&b.execCommand("canRedo",!1),a.current=e,e.editor.setEditorState(e.editorState,{tag:"historic"})),!0;case "clearEditor":return h(),!1;case "clearHistory":return h(),!0;default:return!1}},0),b.addListener("update",({editorState:c,prevEditorState:e,dirtyLeaves:f,dirtyElements:l,tags:p})=>{const m=a.current,u=a.redoStack,q=a.undoStack,t=null===m?null:m.editorState;if(null===m||
-c!==t){f=g(e,c,m,f,l,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(q.push({...m,undoSelection:e.read(r.$getSelection)}),b.execCommand("canUndo",!0));else if(2===f)return;a.current={editor:b,editorState:c}}}))},[h,k,b,a])}function A(){return{current:null,redoStack:[],undoStack:[]}}exports.HistoryPlugin=function({externalHistoryState:b}){const [d]=n.useLexicalComposerContext();z(d,b);return null};exports.createEmptyHistoryState=A;
+/**
+ * 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 LexicalHistoryPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalHistoryPlugin.dev.js') : require('./LexicalHistoryPlugin.prod.js')
+module.exports = LexicalHistoryPlugin;

package/LexicalHistoryPlugin.prod.js

@@ -0,0 +1,13 @@
+/**
+ * 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 n=require("@lexical/react/LexicalComposerContext"),r=require("@lexical/react/withSubscriptions"),v=require("lexical"),w=require("react");
+function x(b,d,k,a,h){if(null===b||0===k.size&&0===a.size)return 0;var g=d._selection,c=b._selection;if(h)return 1;if(null===g||null===c||!c.isCollapsed()||!g.isCollapsed())return 0;var e=Array.from(k);a=Array.from(a);k=d._nodeMap;h=[];for(var f=0;f<e.length;f++){const l=k.get(e[f]);void 0!==l&&h.push(l)}for(e=0;e<a.length;e++)a[e][1]&&(f=k.get(a[e][0]),void 0===f||v.$isRootNode(f)||h.push(f));if(0===h.length)return 0;if(1<h.length)return a=d._nodeMap,d=a.get(g.anchor.key),c=a.get(c.anchor.key),d&&
+c&&!b._nodeMap.has(d.__key)&&v.$isTextNode(d)&&1===d.__text.length&&1===g.anchor.offset?2:0;d=h[0];b=b._nodeMap.get(d.__key);if(!v.$isTextNode(b)||!v.$isTextNode(d)||b.__mode!==d.__mode)return 0;b=b.__text;d=d.__text;if(b===d)return 0;g=g.anchor;c=c.anchor;if(g.key!==c.key||"text"!==g.type)return 0;g=g.offset;c=c.offset;b=d.length-b.length;return 1===b&&c===g-1?2:-1===b&&c===g+1?3:-1===b&&c===g?4:0}
+function y(b,d){let k=Date.now(),a=0;return(h,g,c,e,f,l)=>{const p=Date.now();if(l.has("historic"))return a=0,k=p,2;const m=x(h,g,e,f,b.isComposing()),u=(()=>{if(l.has("without-history"))return 0;if(null===h)return 1;var q=g._selection;const t=h._selection;if(!(0<e.size||0<f.size))return null===t&&null!==q?0:2;q=null===c||c.editor===b;return 0!==m&&m===a&&p<k+d&&q?0:1})();k=p;a=m;return u}}
+function z(b,d,k=1E3){const a=w.useMemo(()=>d||A(),[d]),h=w.useCallback(()=>{a.undoStack=[];a.redoStack=[];a.current=null},[a]);w.useEffect(()=>{const g=y(b,k);return r(b.addListener("command",c=>{switch(c){case "undo":c=a.redoStack;var e=a.undoStack;if(0!==e.length){var f=a.current;const l=e.pop();null!==f&&(c.push(f),b.execCommand("canRedo",!0));0===e.length&&b.execCommand("canUndo",!1);a.current=l;l.editor.setEditorState(l.editorState.clone(l.undoSelection),{tag:"historic"})}return!0;case "redo":return c=
+a.redoStack,e=a.undoStack,0!==c.length&&(f=a.current,null!==f&&(e.push(f),b.execCommand("canUndo",!0)),e=c.pop(),0===c.length&&b.execCommand("canRedo",!1),a.current=e,e.editor.setEditorState(e.editorState,{tag:"historic"})),!0;case "clearEditor":return h(),!1;case "clearHistory":return h(),!0;default:return!1}},0),b.addListener("update",({editorState:c,prevEditorState:e,dirtyLeaves:f,dirtyElements:l,tags:p})=>{const m=a.current,u=a.redoStack,q=a.undoStack,t=null===m?null:m.editorState;if(null===m||
+c!==t){f=g(e,c,m,f,l,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(q.push({...m,undoSelection:e.read(v.$getSelection)}),b.execCommand("canUndo",!0));else if(2===f)return;a.current={editor:b,editorState:c}}}))},[h,k,b,a])}function A(){return{current:null,redoStack:[],undoStack:[]}}exports.HistoryPlugin=function({externalHistoryState:b}){const [d]=n.useLexicalComposerContext();z(d,b);return null};exports.createEmptyHistoryState=A;

package/LexicalHorizontalRulePlugin.dev.js

@@ -0,0 +1,51 @@
+/**
+ * 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 LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var lexical = require('lexical');
+var react = require('react');
+
+/**
+ * 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.
+ *
+ * 
+ */
+const EditorPriority = 0;
+function HorizontalRulePlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    return editor.addListener('command', type => {
+      if (type === 'insertHorizontalRule') {
+        lexical.$log('insertHorizontalRule');
+        const selection = lexical.$getSelection();
+
+        if (selection === null) {
+          return false;
+        }
+
+        const focusNode = selection.focus.getNode();
+
+        if (focusNode !== null) {
+          const horizontalRuleNode = lexical.$createHorizontalRuleNode();
+          selection.insertParagraph();
+          selection.focus.getNode().getTopLevelElementOrThrow().insertBefore(horizontalRuleNode);
+        }
+
+        return true;
+      }
+
+      return false;
+    }, EditorPriority);
+  }, [editor]);
+  return null;
+}
+
+module.exports = HorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.js

@@ -1 +1,9 @@
-'use strict';var b=require("lexical"),d=require("@lexical/react/LexicalComposerContext"),e=require("react");module.exports=function(){const [c]=d.useLexicalComposerContext();e.useEffect(()=>c.addListener("command",a=>{if("insertHorizontalRule"===a){b.$log("insertHorizontalRule");a=b.$getSelection();if(null===a)return!1;if(null!==a.focus.getNode()){const f=b.$createHorizontalRuleNode();a.insertParagraph();a.focus.getNode().getTopLevelElementOrThrow().insertBefore(f)}return!0}return!1},0),[c]);return null};
+/**
+ * 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 LexicalHorizontalRulePlugin = process.env.NODE_ENV === 'development' ? require('./LexicalHorizontalRulePlugin.dev.js') : require('./LexicalHorizontalRulePlugin.prod.js')
+module.exports = LexicalHorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.prod.js

@@ -0,0 +1,7 @@
+/**
+ * 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 b=require("@lexical/react/LexicalComposerContext"),d=require("lexical"),e=require("react");module.exports=function(){const [c]=b.useLexicalComposerContext();e.useEffect(()=>c.addListener("command",a=>{if("insertHorizontalRule"===a){d.$log("insertHorizontalRule");a=d.$getSelection();if(null===a)return!1;if(null!==a.focus.getNode()){const f=d.$createHorizontalRuleNode();a.insertParagraph();a.focus.getNode().getTopLevelElementOrThrow().insertBefore(f)}return!0}return!1},0),[c]);return null};

package/LexicalLinkPlugin.dev.js

@@ -0,0 +1,137 @@
+/**
+ * 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 LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var lexical = require('lexical');
+var LinkNode = require('lexical/LinkNode');
+var react = require('react');
+
+/**
+ * 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.
+ *
+ * 
+ */
+const EditorPriority = 0;
+
+function toggleLink(url) {
+  const selection = lexical.$getSelection();
+  lexical.$log('toggleLink');
+
+  if (selection !== null) {
+    lexical.$setSelection(selection);
+  }
+
+  const sel = lexical.$getSelection();
+
+  if (sel !== null) {
+    const nodes = sel.extract();
+
+    if (url === null) {
+      // Remove LinkNodes
+      nodes.forEach(node => {
+        const parent = node.getParent();
+
+        if (LinkNode.$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
+      let prevParent = null;
+      let linkNode = null;
+
+      if (nodes.length === 1) {
+        const firstNode = nodes[0]; // if the first node is a LinkNode or if its
+        // parent is a LinkNode, we update the URL.
+
+        if (LinkNode.$isLinkNode(firstNode)) {
+          firstNode.setURL(url);
+          return;
+        } else {
+          const parent = firstNode.getParent();
+
+          if (LinkNode.$isLinkNode(parent)) {
+            // set parent to be the current linkNode
+            // so that other nodes in the same parent
+            // aren't handled separately below.
+            linkNode = parent;
+            parent.setURL(url);
+            return;
+          }
+        }
+      }
+
+      nodes.forEach(node => {
+        const parent = node.getParent();
+
+        if (parent === linkNode || parent === null) {
+          return;
+        }
+
+        if (!parent.is(prevParent)) {
+          prevParent = parent;
+          linkNode = LinkNode.$createLinkNode(url);
+
+          if (LinkNode.$isLinkNode(parent)) {
+            if (node.getPreviousSibling() === null) {
+              parent.insertBefore(linkNode);
+            } else {
+              parent.insertAfter(linkNode);
+            }
+          } else {
+            node.insertBefore(linkNode);
+          }
+        }
+
+        if (LinkNode.$isLinkNode(node)) {
+          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 LinkPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    return editor.addListener('command', (type, payload) => {
+      if (type === 'toggleLink') {
+        const url = payload;
+        toggleLink(url);
+        return true;
+      }
+
+      return false;
+    }, EditorPriority);
+  }, [editor]);
+  return null;
+}
+
+module.exports = LinkPlugin;

package/LexicalLinkPlugin.js

@@ -1,3 +1,9 @@
-'use strict';var h=require("@lexical/react/LexicalComposerContext"),k=require("react"),m=require("lexical"),n=require("lexical/LinkNode");
-function p(g){var b=m.$getSelection();m.$log("toggleLink");null!==b&&m.$setSelection(b);b=m.$getSelection();if(null!==b)if(b=b.extract(),null===g)b.forEach(e=>{e=e.getParent();if(n.$isLinkNode(e)){const a=e.getChildren();for(let c=0;c<a.length;c++)e.insertBefore(a[c]);e.remove()}});else{let e=null,a=null;if(1===b.length){var f=b[0];if(n.$isLinkNode(f)){f.setURL(g);return}f=f.getParent();if(n.$isLinkNode(f)){a=f;f.setURL(g);return}}b.forEach(c=>{var d=c.getParent();if(d!==a&&null!==d)if(d.is(e)||(e=
-d,a=n.$createLinkNode(g),n.$isLinkNode(d)?null===c.getPreviousSibling()?d.insertBefore(a):d.insertAfter(a):c.insertBefore(a)),n.$isLinkNode(c)){if(null!==a){d=c.getChildren();for(let l=0;l<d.length;l++)a.append(d[l])}c.remove()}else null!==a&&a.append(c)})}}module.exports=function(){const [g]=h.useLexicalComposerContext();k.useEffect(()=>g.addListener("command",(b,f)=>"toggleLink"===b?(p(f),!0):!1,0),[g]);return null};
+/**
+ * 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 LexicalLinkPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalLinkPlugin.dev.js') : require('./LexicalLinkPlugin.prod.js')
+module.exports = LexicalLinkPlugin;

package/LexicalLinkPlugin.prod.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';var h=require("@lexical/react/LexicalComposerContext"),k=require("lexical"),m=require("lexical/LinkNode"),n=require("react");
+function p(g){var b=k.$getSelection();k.$log("toggleLink");null!==b&&k.$setSelection(b);b=k.$getSelection();if(null!==b)if(b=b.extract(),null===g)b.forEach(e=>{e=e.getParent();if(m.$isLinkNode(e)){const a=e.getChildren();for(let c=0;c<a.length;c++)e.insertBefore(a[c]);e.remove()}});else{let e=null,a=null;if(1===b.length){var f=b[0];if(m.$isLinkNode(f)){f.setURL(g);return}f=f.getParent();if(m.$isLinkNode(f)){a=f;f.setURL(g);return}}b.forEach(c=>{var d=c.getParent();if(d!==a&&null!==d)if(d.is(e)||(e=
+d,a=m.$createLinkNode(g),m.$isLinkNode(d)?null===c.getPreviousSibling()?d.insertBefore(a):d.insertAfter(a):c.insertBefore(a)),m.$isLinkNode(c)){if(null!==a){d=c.getChildren();for(let l=0;l<d.length;l++)a.append(d[l])}c.remove()}else null!==a&&a.append(c)})}}module.exports=function(){const [g]=h.useLexicalComposerContext();n.useEffect(()=>g.addListener("command",(b,f)=>"toggleLink"===b?(p(f),!0):!1,0),[g]);return null};

package/LexicalListPlugin.dev.js

@@ -0,0 +1,67 @@
+/**
+ * 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 LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var list = require('@lexical/list');
+var react = require('react');
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const LowPriority = 1;
+function useList(editor) {
+  react.useEffect(() => {
+    return editor.addListener('command', type => {
+      if (type === 'indentContent') {
+        const hasHandledIndention = list.indentList();
+
+        if (hasHandledIndention) {
+          return true;
+        }
+      } else if (type === 'outdentContent') {
+        const hasHandledIndention = list.outdentList();
+
+        if (hasHandledIndention) {
+          return true;
+        }
+      } else if (type === 'insertOrderedList') {
+        list.insertList(editor, 'ol');
+        return true;
+      } else if (type === 'insertUnorderedList') {
+        list.insertList(editor, 'ul');
+        return true;
+      } else if (type === 'removeList') {
+        list.removeList(editor);
+        return true;
+      }
+
+      return false;
+    }, LowPriority);
+  }, [editor]);
+}
+
+/**
+ * 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 ListPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  useList(editor);
+  return null;
+}
+
+module.exports = ListPlugin;