@lexical/react 0.1.16 → 0.1.19

package/LexicalHistoryPlugin.dev.js

@@ -7,8 +7,7 @@
 'use strict';
 
 var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
-var withSubscriptions = require('@lexical/react/withSubscriptions');
-var lexical = require('lexical');
+var history = require('@lexical/history');
 var react = require('react');
 
 /**
@@ -19,312 +18,11 @@ var react = require('react');
  *
  * 
  */
-const HISTORY_MERGE = 0;
-const HISTORY_PUSH = 1;
-const DISCARD_HISTORY_CANDIDATE = 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 (!lexical.$isRangeSelection(nextSelection) || !lexical.$isRangeSelection(prevSelection) || !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_HISTORY_CANDIDATE;
-    }
-
-    const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
-
-    const mergeAction = (() => {
-      const shouldPushHistory = tags.has('history-push');
-      const shouldMergeHistory = !shouldPushHistory && tags.has('history-merge');
-
-      if (shouldMergeHistory) {
-        return HISTORY_MERGE;
-      }
-
-      if (prevEditorState === null) {
-        return HISTORY_PUSH;
-      }
-
-      const selection = nextEditorState._selection;
-      const prevSelection = prevEditorState._selection;
-      const hasDirtyNodes = dirtyLeaves.size > 0 || dirtyElements.size > 0;
-
-      if (!hasDirtyNodes) {
-        if (prevSelection === null && selection !== null) {
-          return HISTORY_MERGE;
-        }
-
-        return DISCARD_HISTORY_CANDIDATE;
-      }
-
-      const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
-
-      if (shouldPushHistory === false && changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
-        return HISTORY_MERGE;
-      }
-
-      return HISTORY_PUSH;
-    })();
-
-    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]);
+  const historyState = react.useMemo(() => externalHistoryState || history.createEmptyHistoryState(), [externalHistoryState]);
   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 === HISTORY_PUSH) {
-        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_HISTORY_CANDIDATE) {
-        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: []
-  };
+    return history.registerHistory(editor, historyState, delay);
+  }, [delay, editor, historyState]);
 }
 
 /**
@@ -343,5 +41,5 @@ function HistoryPlugin({
   return null;
 }
 
+exports.createEmptyHistoryState = history.createEmptyHistoryState;
 exports.HistoryPlugin = HistoryPlugin;
-exports.createEmptyHistoryState = createEmptyHistoryState;

package/LexicalHistoryPlugin.prod.js

@@ -4,10 +4,4 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var n=require("@lexical/react/LexicalComposerContext"),t=require("@lexical/react/withSubscriptions"),v=require("lexical"),w=require("react");
-function x(b,d,l,a,h){if(null===b||0===l.size&&0===a.size)return 0;var g=d._selection,c=b._selection;if(h)return 1;if(!(v.$isRangeSelection(g)&&v.$isRangeSelection(c)&&c.isCollapsed()&&g.isCollapsed()))return 0;var e=Array.from(l);a=Array.from(a);l=d._nodeMap;h=[];for(var f=0;f<e.length;f++){const k=l.get(e[f]);void 0!==k&&h.push(k)}for(e=0;e<a.length;e++)a[e][1]&&(f=l.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 l=Date.now(),a=0;return(h,g,c,e,f,k)=>{const p=Date.now();if(k.has("historic"))return a=0,l=p,2;const m=x(h,g,e,f,b.isComposing()),u=(()=>{const r=k.has("history-push");if(!r&&k.has("history-merge"))return 0;if(null===h)return 1;var q=g._selection;const A=h._selection;if(!(0<e.size||0<f.size))return null===A&&null!==q?0:2;q=null===c||c.editor===b;return!1===r&&0!==m&&m===a&&p<l+d&&q?0:1})();l=p;a=m;return u}}
-function z(b,d,l=1E3){const a=w.useMemo(()=>d||B(),[d]),h=w.useCallback(()=>{a.undoStack=[];a.redoStack=[];a.current=null},[a]);w.useEffect(()=>{const g=y(b,l);return t(b.addListener("command",c=>{switch(c){case "undo":c=a.redoStack;var e=a.undoStack;if(0!==e.length){var f=a.current;const k=e.pop();null!==f&&(c.push(f),b.execCommand("canRedo",!0));0===e.length&&b.execCommand("canUndo",!1);a.current=k;k.editor.setEditorState(k.editorState.clone(k.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:k,tags:p})=>{const m=a.current,u=a.redoStack,r=a.undoStack,q=null===m?null:m.editorState;if(null===m||
-c!==q){f=g(e,c,m,f,k,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(r.push({...m,undoSelection:e.read(v.$getSelection)}),b.execCommand("canUndo",!0));else if(2===f)return;a.current={editor:b,editorState:c}}}))},[h,l,b,a])}function B(){return{current:null,redoStack:[],undoStack:[]}}exports.HistoryPlugin=function({externalHistoryState:b}){const [d]=n.useLexicalComposerContext();z(d,b);return null};exports.createEmptyHistoryState=B;
+var c=require("@lexical/react/LexicalComposerContext"),d=require("@lexical/history"),g=require("react");function h(a,b,e=1E3){const f=g.useMemo(()=>b||d.createEmptyHistoryState(),[b]);g.useEffect(()=>d.registerHistory(a,f,e),[e,a,f])}exports.createEmptyHistoryState=d.createEmptyHistoryState;exports.HistoryPlugin=function({externalHistoryState:a}){const [b]=c.useLexicalComposerContext();h(b,a);return null};

package/LexicalHorizontalRuleNode.d.ts

@@ -6,7 +6,7 @@
  *
  */
 
-import type {LexicalNode} from 'lexical';
+import type {LexicalNode, LexicalCommand} from 'lexical';
 import {DecoratorNode} from 'lexical';
 export declare class HorizontalRuleNode extends DecoratorNode<React.ReactNode> {
   getType(): string;
@@ -21,3 +21,5 @@ export function $createHorizontalRuleNode(): HorizontalRuleNode;
 export function $isHorizontalRuleNode(
   node: LexicalNode | null | undefined,
 ): boolean;
+
+export var INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;

package/LexicalHorizontalRuleNode.dev.js

@@ -17,6 +17,7 @@ var React = require('react');
  *
  * 
  */
+const INSERT_HORIZONTAL_RULE_COMMAND = lexical.createCommand();
 
 function HorizontalRuleComponent() {
   return /*#__PURE__*/React.createElement("hr", null);
@@ -64,3 +65,4 @@ function $isHorizontalRuleNode(node) {
 exports.$createHorizontalRuleNode = $createHorizontalRuleNode;
 exports.$isHorizontalRuleNode = $isHorizontalRuleNode;
 exports.HorizontalRuleNode = HorizontalRuleNode;
+exports.INSERT_HORIZONTAL_RULE_COMMAND = INSERT_HORIZONTAL_RULE_COMMAND;

package/LexicalHorizontalRuleNode.js.flow

@@ -7,7 +7,7 @@
  * @flow strict
  */
 
-import type {LexicalNode} from 'lexical';
+import type {LexicalNode, LexicalCommand} from 'lexical';
 
 import {DecoratorNode} from 'lexical';
 
@@ -22,4 +22,8 @@ declare export class HorizontalRuleNode extends DecoratorNode<React$Node> {
 }
 
 declare export function $createHorizontalRuleNode(): HorizontalRuleNode;
-declare export function $isHorizontalRuleNode(node: ?LexicalNode): boolean;
+declare export function $isHorizontalRuleNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof HorizontalRuleNode);
+
+declare export var INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;

package/LexicalHorizontalRuleNode.prod.js

@@ -4,5 +4,5 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var b=require("lexical"),c=require("react");function d(){return c.createElement("hr",null)}class e extends b.DecoratorNode{static getType(){return"horizontalrule"}static clone(a){return new e(a.__state,a.__key)}createDOM(){const a=document.createElement("div");a.style.display="contents";return a}getTextContent(){return"\n"}isTopLevel(){return!0}updateDOM(){return!1}decorate(){return c.createElement(d,null)}}exports.$createHorizontalRuleNode=function(){return new e};
-exports.$isHorizontalRuleNode=function(a){return a instanceof e};exports.HorizontalRuleNode=e;
+var b=require("lexical"),c=require("react");const d=b.createCommand();function e(){return c.createElement("hr",null)}class f extends b.DecoratorNode{static getType(){return"horizontalrule"}static clone(a){return new f(a.__state,a.__key)}createDOM(){const a=document.createElement("div");a.style.display="contents";return a}getTextContent(){return"\n"}isTopLevel(){return!0}updateDOM(){return!1}decorate(){return c.createElement(e,null)}}exports.$createHorizontalRuleNode=function(){return new f};
+exports.$isHorizontalRuleNode=function(a){return a instanceof f};exports.HorizontalRuleNode=f;exports.INSERT_HORIZONTAL_RULE_COMMAND=d;

package/LexicalLinkPlugin.dev.js

@@ -6,9 +6,9 @@
  */
 'use strict';
 
+var link = require('@lexical/link');
 var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 var lexical = require('lexical');
-var LinkNode = require('lexical/LinkNode');
 var react = require('react');
 
 /**
@@ -38,7 +38,7 @@ function toggleLink(url) {
       nodes.forEach(node => {
         const parent = node.getParent();
 
-        if (LinkNode.$isLinkNode(parent)) {
+        if (link.$isLinkNode(parent)) {
           const children = parent.getChildren();
 
           for (let i = 0; i < children.length; i++) {
@@ -50,42 +50,40 @@ function toggleLink(url) {
       });
     } 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)) {
+        if (link.$isLinkNode(firstNode)) {
           firstNode.setURL(url);
           return;
         } else {
           const parent = firstNode.getParent();
 
-          if (LinkNode.$isLinkNode(parent)) {
+          if (link.$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;
           }
         }
       }
 
+      let prevParent = null;
+      let linkNode = null;
       nodes.forEach(node => {
         const parent = node.getParent();
 
-        if (parent === linkNode || parent === null) {
+        if (parent === linkNode || parent === null || lexical.$isElementNode(node) && !node.isInline()) {
           return;
         }
 
         if (!parent.is(prevParent)) {
           prevParent = parent;
-          linkNode = LinkNode.$createLinkNode(url);
+          linkNode = link.$createLinkNode(url);
 
-          if (LinkNode.$isLinkNode(parent)) {
+          if (link.$isLinkNode(parent)) {
             if (node.getPreviousSibling() === null) {
               parent.insertBefore(linkNode);
             } else {
@@ -96,7 +94,7 @@ function toggleLink(url) {
           }
         }
 
-        if (LinkNode.$isLinkNode(node)) {
+        if (link.$isLinkNode(node)) {
           if (linkNode !== null) {
             const children = node.getChildren();
 
@@ -120,14 +118,15 @@ function toggleLink(url) {
 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;
+    if (!editor.hasNodes([link.LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+  }, [editor]);
+  react.useEffect(() => {
+    return editor.registerCommand(link.TOGGLE_LINK_COMMAND, payload => {
+      const url = payload;
+      toggleLink(url);
+      return true;
     }, EditorPriority);
   }, [editor]);
   return null;

package/LexicalLinkPlugin.prod.js

@@ -4,6 +4,7 @@
  * 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/react/LexicalComposerContext"),k=require("lexical"),m=require("lexical/LinkNode"),n=require("react");
-function p(g){var b=k.$getSelection();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};
+var g=require("@lexical/link"),k=require("@lexical/react/LexicalComposerContext"),m=require("lexical"),n=require("react");
+function p(e){var b=m.$getSelection();null!==b&&m.$setSelection(b);b=m.$getSelection();if(null!==b)if(b=b.extract(),null===e)b.forEach(f=>{f=f.getParent();if(g.$isLinkNode(f)){const c=f.getChildren();for(let a=0;a<c.length;a++)f.insertBefore(c[a]);f.remove()}});else{if(1===b.length){var h=b[0];if(g.$isLinkNode(h)){h.setURL(e);return}h=h.getParent();if(g.$isLinkNode(h)){h.setURL(e);return}}let f=null,c=null;b.forEach(a=>{var d=a.getParent();if(d!==c&&null!==d&&(!m.$isElementNode(a)||a.isInline()))if(d.is(f)||
+(f=d,c=g.$createLinkNode(e),g.$isLinkNode(d)?null===a.getPreviousSibling()?d.insertBefore(c):d.insertAfter(c):a.insertBefore(c)),g.$isLinkNode(a)){if(null!==c){d=a.getChildren();for(let l=0;l<d.length;l++)c.append(d[l])}a.remove()}else null!==c&&c.append(a)})}}
+module.exports=function(){const [e]=k.useLexicalComposerContext();n.useEffect(()=>{if(!e.hasNodes([g.LinkNode]))throw Error("LinkPlugin: LinkNode not registered on editor");},[e]);n.useEffect(()=>e.registerCommand(g.TOGGLE_LINK_COMMAND,b=>{p(b);return!0},0),[e]);return null};

package/LexicalListPlugin.dev.js

@@ -8,6 +8,8 @@
 
 var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 var list = require('@lexical/list');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
 var react = require('react');
 
 /**
@@ -21,38 +23,40 @@ var react = require('react');
 const LowPriority = 1;
 function useList(editor) {
   react.useEffect(() => {
-    return editor.addListener('command', type => {
-      if (type === 'indentContent') {
-        const hasHandledIndention = list.indentList();
+    return utils.mergeRegister(editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, () => {
+      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');
+      if (hasHandledIndention) {
         return true;
-      } else if (type === 'removeList') {
-        list.removeList(editor);
+      }
+
+      return false;
+    }, LowPriority), editor.registerCommand(lexical.OUTDENT_CONTENT_COMMAND, () => {
+      const hasHandledIndention = list.outdentList();
+
+      if (hasHandledIndention) {
         return true;
-      } else if (type === 'insertParagraph') {
-        const hasHandledInsertParagraph = list.$handleListInsertParagraph();
+      }
 
-        if (hasHandledInsertParagraph) {
-          return true;
-        }
+      return false;
+    }, LowPriority), editor.registerCommand(list.INSERT_ORDERED_LIST_COMMAND, () => {
+      list.insertList(editor, 'ol');
+      return true;
+    }, LowPriority), editor.registerCommand(list.INSERT_UNORDERED_LIST_COMMAND, () => {
+      list.insertList(editor, 'ul');
+      return true;
+    }, LowPriority), editor.registerCommand(list.REMOVE_LIST_COMMAND, () => {
+      list.removeList(editor);
+      return true;
+    }, LowPriority), editor.registerCommand(lexical.INSERT_PARAGRAPH_COMMAND, () => {
+      const hasHandledInsertParagraph = list.$handleListInsertParagraph();
+
+      if (hasHandledInsertParagraph) {
+        return true;
       }
 
       return false;
-    }, LowPriority);
+    }, LowPriority));
   }, [editor]);
 }
 

package/LexicalListPlugin.prod.js

@@ -4,5 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var b=require("@lexical/react/LexicalComposerContext"),d=require("@lexical/list"),e=require("react");
-function f(a){e.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(d.indentList())return!0}else if("outdentContent"===c){if(d.outdentList())return!0}else{if("insertOrderedList"===c)return d.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return d.insertList(a,"ul"),!0;if("removeList"===c)return d.removeList(a),!0;if("insertParagraph"===c&&d.$handleListInsertParagraph())return!0}return!1},1),[a])}module.exports=function(){const [a]=b.useLexicalComposerContext();f(a);return null};
+var b=require("@lexical/react/LexicalComposerContext"),c=require("@lexical/list"),d=require("@lexical/utils"),e=require("lexical"),f=require("react");
+function g(a){f.useEffect(()=>d.mergeRegister(a.registerCommand(e.INDENT_CONTENT_COMMAND,()=>c.indentList()?!0:!1,1),a.registerCommand(e.OUTDENT_CONTENT_COMMAND,()=>c.outdentList()?!0:!1,1),a.registerCommand(c.INSERT_ORDERED_LIST_COMMAND,()=>{c.insertList(a,"ol");return!0},1),a.registerCommand(c.INSERT_UNORDERED_LIST_COMMAND,()=>{c.insertList(a,"ul");return!0},1),a.registerCommand(c.REMOVE_LIST_COMMAND,()=>{c.removeList(a);return!0},1),a.registerCommand(e.INSERT_PARAGRAPH_COMMAND,()=>c.$handleListInsertParagraph()?
+!0:!1,1)),[a])}module.exports=function(){const [a]=b.useLexicalComposerContext();g(a);return null};

package/{LexicalAutoFormatterPlugin.d.ts → LexicalMarkdownShortcutPlugin.d.ts}

@@ -6,4 +6,4 @@
  *
  */
 
-export default function LexicalAutoFormatterPlugin(): React.ReactNode;
+export default function LexicalMarkdownShortcutPlugin(): React.ReactNode;

package/LexicalMarkdownShortcutPlugin.dev.js

@@ -0,0 +1,42 @@
+/**
+ * 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 markdown = require('@lexical/markdown');
+var LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNode');
+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.
+ *
+ * 
+ */
+function useMarkdownShortcuts(editor) {
+  react.useEffect(() => {
+    return markdown.registerMarkdownShortcuts(editor, LexicalHorizontalRuleNode.$createHorizontalRuleNode);
+  }, [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 LexicalMarkdownShortcutPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  useMarkdownShortcuts(editor);
+  return null;
+}
+
+module.exports = LexicalMarkdownShortcutPlugin;

package/LexicalMarkdownShortcutPlugin.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 LexicalMarkdownShortcutPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalMarkdownShortcutPlugin.dev.js') : require('./LexicalMarkdownShortcutPlugin.prod.js')
+module.exports = LexicalMarkdownShortcutPlugin;