@lexical/react 0.13.1 → 0.14.1

package/LexicalHorizontalRuleNode.dev.esm.js

@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { mergeRegister } from '@lexical/utils';
+import { createCommand, DecoratorNode, $applyNodeReplacement, $isNodeSelection, $getSelection, $getNodeByKey, CLICK_COMMAND, COMMAND_PRIORITY_LOW, KEY_DELETE_COMMAND, KEY_BACKSPACE_COMMAND } from 'lexical';
+import * as React from 'react';
+import { useCallback, useEffect } from '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 INSERT_HORIZONTAL_RULE_COMMAND = createCommand('INSERT_HORIZONTAL_RULE_COMMAND');
+function HorizontalRuleComponent({
+  nodeKey
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+  const onDelete = useCallback(event => {
+    if (isSelected && $isNodeSelection($getSelection())) {
+      event.preventDefault();
+      const node = $getNodeByKey(nodeKey);
+      if ($isHorizontalRuleNode(node)) {
+        node.remove();
+        return true;
+      }
+    }
+    return false;
+  }, [isSelected, nodeKey]);
+  useEffect(() => {
+    return mergeRegister(editor.registerCommand(CLICK_COMMAND, event => {
+      const hrElem = editor.getElementByKey(nodeKey);
+      if (event.target === hrElem) {
+        if (!event.shiftKey) {
+          clearSelection();
+        }
+        setSelected(!isSelected);
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_DELETE_COMMAND, onDelete, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_BACKSPACE_COMMAND, onDelete, COMMAND_PRIORITY_LOW));
+  }, [clearSelection, editor, isSelected, nodeKey, onDelete, setSelected]);
+  useEffect(() => {
+    const hrElem = editor.getElementByKey(nodeKey);
+    if (hrElem !== null) {
+      hrElem.className = isSelected ? 'selected' : '';
+    }
+  }, [editor, isSelected, nodeKey]);
+  return null;
+}
+class HorizontalRuleNode extends DecoratorNode {
+  static getType() {
+    return 'horizontalrule';
+  }
+  static clone(node) {
+    return new HorizontalRuleNode(node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createHorizontalRuleNode();
+  }
+  static importDOM() {
+    return {
+      hr: () => ({
+        conversion: convertHorizontalRuleElement,
+        priority: 0
+      })
+    };
+  }
+  exportJSON() {
+    return {
+      type: 'horizontalrule',
+      version: 1
+    };
+  }
+  exportDOM() {
+    return {
+      element: document.createElement('hr')
+    };
+  }
+  createDOM() {
+    return document.createElement('hr');
+  }
+  getTextContent() {
+    return '\n';
+  }
+  isInline() {
+    return false;
+  }
+  updateDOM() {
+    return false;
+  }
+  decorate() {
+    return /*#__PURE__*/React.createElement(HorizontalRuleComponent, {
+      nodeKey: this.__key
+    });
+  }
+}
+function convertHorizontalRuleElement() {
+  return {
+    node: $createHorizontalRuleNode()
+  };
+}
+function $createHorizontalRuleNode() {
+  return $applyNodeReplacement(new HorizontalRuleNode());
+}
+function $isHorizontalRuleNode(node) {
+  return node instanceof HorizontalRuleNode;
+}
+
+export { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND };

package/LexicalHorizontalRuleNode.dev.js

@@ -31,6 +31,7 @@ function HorizontalRuleComponent({
       const node = lexical.$getNodeByKey(nodeKey);
       if ($isHorizontalRuleNode(node)) {
         node.remove();
+        return true;
       }
     }
     return false;

package/LexicalHorizontalRuleNode.esm.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.
+ */
+import * as modDev from './LexicalHorizontalRuleNode.dev.esm.js';
+import * as modProd from './LexicalHorizontalRuleNode.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+export const $isHorizontalRuleNode = mod.$isHorizontalRuleNode;
+export const HorizontalRuleNode = mod.HorizontalRuleNode;
+export const INSERT_HORIZONTAL_RULE_COMMAND = mod.INSERT_HORIZONTAL_RULE_COMMAND;

package/LexicalHorizontalRuleNode.js

@@ -5,5 +5,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict'
-const LexicalHorizontalRuleNode = process.env.NODE_ENV === 'development' ? require('./LexicalHorizontalRuleNode.dev.js') : require('./LexicalHorizontalRuleNode.prod.js')
+const LexicalHorizontalRuleNode = process.env.NODE_ENV === 'development' ? require('./LexicalHorizontalRuleNode.dev.js') : require('./LexicalHorizontalRuleNode.prod.js');
 module.exports = LexicalHorizontalRuleNode;

package/LexicalHorizontalRuleNode.prod.esm.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.
+ */
+import{useLexicalComposerContext as e}from"@lexical/react/LexicalComposerContext";import{useLexicalNodeSelection as t}from"@lexical/react/useLexicalNodeSelection";import{mergeRegister as r}from"@lexical/utils";import{createCommand as n,DecoratorNode as o,$applyNodeReplacement as i,$isNodeSelection as c,$getSelection as a,$getNodeByKey as l,CLICK_COMMAND as u,COMMAND_PRIORITY_LOW as m,KEY_DELETE_COMMAND as s,KEY_BACKSPACE_COMMAND as p}from"lexical";import*as f from"react";import{useCallback as d,useEffect as x}from"react";const y=n("INSERT_HORIZONTAL_RULE_COMMAND");function O({nodeKey:n}){const[o]=e(),[i,f,y]=t(n),O=d((e=>{if(i&&c(a())){e.preventDefault();const t=l(n);if(E(t))return t.remove(),!0}return!1}),[i,n]);return x((()=>r(o.registerCommand(u,(e=>{const t=o.getElementByKey(n);return e.target===t&&(e.shiftKey||y(),f(!i),!0)}),m),o.registerCommand(s,O,m),o.registerCommand(p,O,m))),[y,o,i,n,O,f]),x((()=>{const e=o.getElementByKey(n);null!==e&&(e.className=i?"selected":"")}),[o,i,n]),null}class g extends o{static getType(){return"horizontalrule"}static clone(e){return new g(e.__key)}static importJSON(e){return C()}static importDOM(){return{hr:()=>({conversion:h,priority:0})}}exportJSON(){return{type:"horizontalrule",version:1}}exportDOM(){return{element:document.createElement("hr")}}createDOM(){return document.createElement("hr")}getTextContent(){return"\n"}isInline(){return!1}updateDOM(){return!1}decorate(){return f.createElement(O,{nodeKey:this.__key})}}function h(){return{node:C()}}function C(){return i(new g)}function E(e){return e instanceof g}export{C as $createHorizontalRuleNode,E as $isHorizontalRuleNode,g as HorizontalRuleNode,y as INSERT_HORIZONTAL_RULE_COMMAND};

package/LexicalHorizontalRuleNode.prod.js

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict';var a=require("@lexical/react/LexicalComposerContext"),f=require("@lexical/react/useLexicalNodeSelection"),g=require("@lexical/utils"),k=require("lexical"),n=require("react");let p=k.createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
-function q({nodeKey:b}){let [d]=a.useLexicalComposerContext(),[e,l,m]=f.useLexicalNodeSelection(b),h=n.useCallback(c=>{e&&k.$isNodeSelection(k.$getSelection())&&(c.preventDefault(),c=k.$getNodeByKey(b),r(c)&&c.remove());return!1},[e,b]);n.useEffect(()=>g.mergeRegister(d.registerCommand(k.CLICK_COMMAND,c=>{let v=d.getElementByKey(b);return c.target===v?(c.shiftKey||m(),l(!e),!0):!1},k.COMMAND_PRIORITY_LOW),d.registerCommand(k.KEY_DELETE_COMMAND,h,k.COMMAND_PRIORITY_LOW),d.registerCommand(k.KEY_BACKSPACE_COMMAND,
+function q({nodeKey:b}){let [d]=a.useLexicalComposerContext(),[e,l,m]=f.useLexicalNodeSelection(b),h=n.useCallback(c=>e&&k.$isNodeSelection(k.$getSelection())&&(c.preventDefault(),c=k.$getNodeByKey(b),r(c))?(c.remove(),!0):!1,[e,b]);n.useEffect(()=>g.mergeRegister(d.registerCommand(k.CLICK_COMMAND,c=>{let v=d.getElementByKey(b);return c.target===v?(c.shiftKey||m(),l(!e),!0):!1},k.COMMAND_PRIORITY_LOW),d.registerCommand(k.KEY_DELETE_COMMAND,h,k.COMMAND_PRIORITY_LOW),d.registerCommand(k.KEY_BACKSPACE_COMMAND,
 h,k.COMMAND_PRIORITY_LOW)),[m,d,e,b,h,l]);n.useEffect(()=>{let c=d.getElementByKey(b);null!==c&&(c.className=e?"selected":"")},[d,e,b]);return null}
 class t extends k.DecoratorNode{static getType(){return"horizontalrule"}static clone(b){return new t(b.__key)}static importJSON(){return u()}static importDOM(){return{hr:()=>({conversion:w,priority:0})}}exportJSON(){return{type:"horizontalrule",version:1}}exportDOM(){return{element:document.createElement("hr")}}createDOM(){return document.createElement("hr")}getTextContent(){return"\n"}isInline(){return!1}updateDOM(){return!1}decorate(){return n.createElement(q,{nodeKey:this.__key})}}
 function w(){return{node:u()}}function u(){return k.$applyNodeReplacement(new t)}function r(b){return b instanceof t}exports.$createHorizontalRuleNode=u;exports.$isHorizontalRuleNode=r;exports.HorizontalRuleNode=t;exports.INSERT_HORIZONTAL_RULE_COMMAND=p

package/LexicalHorizontalRulePlugin.dev.esm.js

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { INSERT_HORIZONTAL_RULE_COMMAND, $createHorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
+import { $insertNodeToNearestRoot } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import { useEffect } from '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 HorizontalRulePlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, type => {
+      const selection = $getSelection();
+      if (!$isRangeSelection(selection)) {
+        return false;
+      }
+      const focusNode = selection.focus.getNode();
+      if (focusNode !== null) {
+        const horizontalRuleNode = $createHorizontalRuleNode();
+        $insertNodeToNearestRoot(horizontalRuleNode);
+      }
+      return true;
+    }, COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+}
+
+export { HorizontalRulePlugin };

package/LexicalHorizontalRulePlugin.esm.js

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+import * as modDev from './LexicalHorizontalRulePlugin.dev.esm.js';
+import * as modProd from './LexicalHorizontalRulePlugin.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const HorizontalRulePlugin = mod.HorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.js

@@ -5,5 +5,5 @@
  * 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')
+const LexicalHorizontalRulePlugin = process.env.NODE_ENV === 'development' ? require('./LexicalHorizontalRulePlugin.dev.js') : require('./LexicalHorizontalRulePlugin.prod.js');
 module.exports = LexicalHorizontalRulePlugin;

package/LexicalHorizontalRulePlugin.prod.esm.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.
+ */
+import{useLexicalComposerContext as o}from"@lexical/react/LexicalComposerContext";import{INSERT_HORIZONTAL_RULE_COMMAND as r,$createHorizontalRuleNode as t}from"@lexical/react/LexicalHorizontalRuleNode";import{$insertNodeToNearestRoot as e}from"@lexical/utils";import{$getSelection as i,$isRangeSelection as l,COMMAND_PRIORITY_EDITOR as c}from"lexical";import{useEffect as m}from"react";function n(){const[n]=o();return m((()=>n.registerCommand(r,(o=>{const r=i();if(!l(r))return!1;if(null!==r.focus.getNode()){const o=t();e(o)}return!0}),c)),[n]),null}export{n as HorizontalRulePlugin};

package/LexicalLinkPlugin.dev.esm.js

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+import { LinkNode, TOGGLE_LINK_COMMAND, toggleLink } from '@lexical/link';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { mergeRegister, objectKlassEquals } from '@lexical/utils';
+import { COMMAND_PRIORITY_LOW, PASTE_COMMAND, $getSelection, $isRangeSelection, $isElementNode } from 'lexical';
+import { useEffect } from '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 LinkPlugin({
+  validateUrl
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+    return mergeRegister(editor.registerCommand(TOGGLE_LINK_COMMAND, payload => {
+      if (payload === null) {
+        toggleLink(payload);
+        return true;
+      } else if (typeof payload === 'string') {
+        if (validateUrl === undefined || validateUrl(payload)) {
+          toggleLink(payload);
+          return true;
+        }
+        return false;
+      } else {
+        const {
+          url,
+          target,
+          rel,
+          title
+        } = payload;
+        toggleLink(url, {
+          rel,
+          target,
+          title
+        });
+        return true;
+      }
+    }, COMMAND_PRIORITY_LOW), validateUrl !== undefined ? editor.registerCommand(PASTE_COMMAND, event => {
+      const selection = $getSelection();
+      if (!$isRangeSelection(selection) || selection.isCollapsed() || !objectKlassEquals(event, ClipboardEvent)) {
+        return false;
+      }
+      const clipboardEvent = event;
+      if (clipboardEvent.clipboardData === null) {
+        return false;
+      }
+      const clipboardText = clipboardEvent.clipboardData.getData('text');
+      if (!validateUrl(clipboardText)) {
+        return false;
+      }
+      // If we select nodes that are elements then avoid applying the link.
+      if (!selection.getNodes().some(node => $isElementNode(node))) {
+        editor.dispatchCommand(TOGGLE_LINK_COMMAND, clipboardText);
+        event.preventDefault();
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW) : () => {
+      // Don't paste arbritrary text as a link when there's no validate function
+    });
+  }, [editor, validateUrl]);
+  return null;
+}
+
+export { LinkPlugin };

package/LexicalLinkPlugin.dev.js

@@ -53,10 +53,14 @@ function LinkPlugin({
       }
     }, lexical.COMMAND_PRIORITY_LOW), validateUrl !== undefined ? editor.registerCommand(lexical.PASTE_COMMAND, event => {
       const selection = lexical.$getSelection();
-      if (!lexical.$isRangeSelection(selection) || selection.isCollapsed() || !(event instanceof ClipboardEvent) || event.clipboardData == null) {
+      if (!lexical.$isRangeSelection(selection) || selection.isCollapsed() || !utils.objectKlassEquals(event, ClipboardEvent)) {
         return false;
       }
-      const clipboardText = event.clipboardData.getData('text');
+      const clipboardEvent = event;
+      if (clipboardEvent.clipboardData === null) {
+        return false;
+      }
+      const clipboardText = clipboardEvent.clipboardData.getData('text');
       if (!validateUrl(clipboardText)) {
         return false;
       }

package/LexicalLinkPlugin.esm.js

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+import * as modDev from './LexicalLinkPlugin.dev.esm.js';
+import * as modProd from './LexicalLinkPlugin.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const LinkPlugin = mod.LinkPlugin;

package/LexicalLinkPlugin.js

@@ -5,5 +5,5 @@
  * 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')
+const LexicalLinkPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalLinkPlugin.dev.js') : require('./LexicalLinkPlugin.prod.js');
 module.exports = LexicalLinkPlugin;

package/LexicalLinkPlugin.prod.esm.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.
+ */
+import{LinkNode as t,TOGGLE_LINK_COMMAND as r,toggleLink as e}from"@lexical/link";import{useLexicalComposerContext as o}from"@lexical/react/LexicalComposerContext";import{mergeRegister as i,objectKlassEquals as n}from"@lexical/utils";import{COMMAND_PRIORITY_LOW as l,PASTE_COMMAND as a,$getSelection as m,$isRangeSelection as s,$isElementNode as c}from"lexical";import{useEffect as d}from"react";function u({validateUrl:u}){const[p]=o();return d((()=>{if(!p.hasNodes([t]))throw new Error("LinkPlugin: LinkNode not registered on editor");return i(p.registerCommand(r,(t=>{if(null===t)return e(t),!0;if("string"==typeof t)return!(void 0!==u&&!u(t))&&(e(t),!0);{const{url:r,target:o,rel:i,title:n}=t;return e(r,{rel:i,target:o,title:n}),!0}}),l),void 0!==u?p.registerCommand(a,(t=>{const e=m();if(!s(e)||e.isCollapsed()||!n(t,ClipboardEvent))return!1;const o=t;if(null===o.clipboardData)return!1;const i=o.clipboardData.getData("text");return!!u(i)&&(!e.getNodes().some((t=>c(t)))&&(p.dispatchCommand(r,i),t.preventDefault(),!0))}),l):()=>{})}),[p,u]),null}export{u as LinkPlugin};

package/LexicalLinkPlugin.prod.js

@@ -6,4 +6,4 @@
  */
 'use strict';var b=require("@lexical/link"),c=require("@lexical/react/LexicalComposerContext"),k=require("@lexical/utils"),l=require("lexical"),m=require("react");
 exports.LinkPlugin=function({validateUrl:d}){let [e]=c.useLexicalComposerContext();m.useEffect(()=>{if(!e.hasNodes([b.LinkNode]))throw Error("LinkPlugin: LinkNode not registered on editor");return k.mergeRegister(e.registerCommand(b.TOGGLE_LINK_COMMAND,a=>{if(null===a)return b.toggleLink(a),!0;if("string"===typeof a)return void 0===d||d(a)?(b.toggleLink(a),!0):!1;let {url:f,target:g,rel:h,title:n}=a;b.toggleLink(f,{rel:h,target:g,title:n});return!0},l.COMMAND_PRIORITY_LOW),void 0!==d?e.registerCommand(l.PASTE_COMMAND,
-a=>{let f=l.$getSelection();if(!l.$isRangeSelection(f)||f.isCollapsed()||!(a instanceof ClipboardEvent)||null==a.clipboardData)return!1;let g=a.clipboardData.getData("text");return d(g)?f.getNodes().some(h=>l.$isElementNode(h))?!1:(e.dispatchCommand(b.TOGGLE_LINK_COMMAND,g),a.preventDefault(),!0):!1},l.COMMAND_PRIORITY_LOW):()=>{})},[e,d]);return null}
+a=>{let f=l.$getSelection();if(!l.$isRangeSelection(f)||f.isCollapsed()||!k.objectKlassEquals(a,ClipboardEvent)||null===a.clipboardData)return!1;let g=a.clipboardData.getData("text");return d(g)?f.getNodes().some(h=>l.$isElementNode(h))?!1:(e.dispatchCommand(b.TOGGLE_LINK_COMMAND,g),a.preventDefault(),!0):!1},l.COMMAND_PRIORITY_LOW):()=>{})},[e,d]);return null}

package/LexicalListPlugin.dev.esm.js

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { INSERT_ORDERED_LIST_COMMAND, insertList, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, removeList, $handleListInsertParagraph, ListNode, ListItemNode } from '@lexical/list';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect } from 'react';
+import { mergeRegister } from '@lexical/utils';
+import { COMMAND_PRIORITY_LOW, INSERT_PARAGRAPH_COMMAND } from '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 useList(editor) {
+  useEffect(() => {
+    return mergeRegister(editor.registerCommand(INSERT_ORDERED_LIST_COMMAND, () => {
+      insertList(editor, 'number');
+      return true;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_UNORDERED_LIST_COMMAND, () => {
+      insertList(editor, 'bullet');
+      return true;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(REMOVE_LIST_COMMAND, () => {
+      removeList(editor);
+      return true;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_PARAGRAPH_COMMAND, () => {
+      const hasHandledInsertParagraph = $handleListInsertParagraph();
+      if (hasHandledInsertParagraph) {
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW));
+  }, [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] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([ListNode, ListItemNode])) {
+      throw new Error('ListPlugin: ListNode and/or ListItemNode not registered on editor');
+    }
+  }, [editor]);
+  useList(editor);
+  return null;
+}
+
+export { ListPlugin };

package/LexicalListPlugin.esm.js

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+import * as modDev from './LexicalListPlugin.dev.esm.js';
+import * as modProd from './LexicalListPlugin.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const ListPlugin = mod.ListPlugin;

package/LexicalListPlugin.js

@@ -5,5 +5,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict'
-const LexicalListPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalListPlugin.dev.js') : require('./LexicalListPlugin.prod.js')
+const LexicalListPlugin = process.env.NODE_ENV === 'development' ? require('./LexicalListPlugin.dev.js') : require('./LexicalListPlugin.prod.js');
 module.exports = LexicalListPlugin;

package/LexicalListPlugin.prod.esm.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.
+ */
+import{INSERT_ORDERED_LIST_COMMAND as r,insertList as e,INSERT_UNORDERED_LIST_COMMAND as o,REMOVE_LIST_COMMAND as t,removeList as i,$handleListInsertParagraph as m,ListNode as n,ListItemNode as l}from"@lexical/list";import{useLexicalComposerContext as s}from"@lexical/react/LexicalComposerContext";import{useEffect as a}from"react";import{mergeRegister as c}from"@lexical/utils";import{COMMAND_PRIORITY_LOW as d,INSERT_PARAGRAPH_COMMAND as f}from"lexical";function u(){const[u]=s();return a((()=>{if(!u.hasNodes([n,l]))throw new Error("ListPlugin: ListNode and/or ListItemNode not registered on editor")}),[u]),function(n){a((()=>c(n.registerCommand(r,(()=>(e(n,"number"),!0)),d),n.registerCommand(o,(()=>(e(n,"bullet"),!0)),d),n.registerCommand(t,(()=>(i(n),!0)),d),n.registerCommand(f,(()=>!!m()),d))),[n])}(u),null}export{u as ListPlugin};

package/LexicalMarkdownShortcutPlugin.dev.esm.js

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+import { TRANSFORMERS, registerMarkdownShortcuts } from '@lexical/markdown';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { HorizontalRuleNode, $isHorizontalRuleNode, $createHorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
+import { useEffect } from '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 HR = {
+  dependencies: [HorizontalRuleNode],
+  export: node => {
+    return $isHorizontalRuleNode(node) ? '***' : null;
+  },
+  regExp: /^(---|\*\*\*|___)\s?$/,
+  replace: (parentNode, _1, _2, isImport) => {
+    const line = $createHorizontalRuleNode();
+
+    // TODO: Get rid of isImport flag
+    if (isImport || parentNode.getNextSibling() != null) {
+      parentNode.replace(line);
+    } else {
+      parentNode.insertBefore(line);
+    }
+    line.selectNext();
+  },
+  type: 'element'
+};
+const DEFAULT_TRANSFORMERS = [HR, ...TRANSFORMERS];
+function MarkdownShortcutPlugin({
+  transformers = DEFAULT_TRANSFORMERS
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return registerMarkdownShortcuts(editor, transformers);
+  }, [editor, transformers]);
+  return null;
+}
+
+export { DEFAULT_TRANSFORMERS, MarkdownShortcutPlugin };

package/LexicalMarkdownShortcutPlugin.esm.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import * as modDev from './LexicalMarkdownShortcutPlugin.dev.esm.js';
+import * as modProd from './LexicalMarkdownShortcutPlugin.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const DEFAULT_TRANSFORMERS = mod.DEFAULT_TRANSFORMERS;
+export const MarkdownShortcutPlugin = mod.MarkdownShortcutPlugin;

package/LexicalMarkdownShortcutPlugin.js

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

package/LexicalMarkdownShortcutPlugin.prod.esm.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.
+ */
+import{TRANSFORMERS as e,registerMarkdownShortcuts as r}from"@lexical/markdown";import{useLexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";import{HorizontalRuleNode as o,$isHorizontalRuleNode as l,$createHorizontalRuleNode as n}from"@lexical/react/LexicalHorizontalRuleNode";import{useEffect as c}from"react";const i=[{dependencies:[o],export:e=>l(e)?"***":null,regExp:/^(---|\*\*\*|___)\s?$/,replace:(e,r,t,o)=>{const l=n();o||null!=e.getNextSibling()?e.replace(l):e.insertBefore(l),l.selectNext()},type:"element"},...e];function a({transformers:e=i}){const[o]=t();return c((()=>r(o,e)),[o,e]),null}export{i as DEFAULT_TRANSFORMERS,a as MarkdownShortcutPlugin};

package/LexicalNestedComposer.dev.esm.js

@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+import { useCollaborationContext } from '@lexical/react/LexicalCollaborationContext';
+import { LexicalComposerContext, createLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import * as React from 'react';
+import { useRef, useContext, useMemo, useEffect } from '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 LexicalNestedComposer({
+  initialEditor,
+  children,
+  initialNodes,
+  initialTheme,
+  skipCollabChecks
+}) {
+  const wasCollabPreviouslyReadyRef = useRef(false);
+  const parentContext = useContext(LexicalComposerContext);
+  if (parentContext == null) {
+    {
+      throw Error(`Unexpected parent context null on a nested composer`);
+    }
+  }
+  const [parentEditor, {
+    getTheme: getParentTheme
+  }] = parentContext;
+  const composerContext = useMemo(() => {
+    const composerTheme = initialTheme || getParentTheme() || undefined;
+    const context = createLexicalComposerContext(parentContext, composerTheme);
+    if (composerTheme !== undefined) {
+      initialEditor._config.theme = composerTheme;
+    }
+    initialEditor._parentEditor = parentEditor;
+    if (!initialNodes) {
+      const parentNodes = initialEditor._nodes = new Map(parentEditor._nodes);
+      for (const [type, entry] of parentNodes) {
+        initialEditor._nodes.set(type, {
+          exportDOM: entry.exportDOM,
+          klass: entry.klass,
+          replace: entry.replace,
+          replaceWithKlass: entry.replaceWithKlass,
+          transforms: new Set()
+        });
+      }
+    } else {
+      for (let klass of initialNodes) {
+        let replace = null;
+        let replaceWithKlass = null;
+        if (typeof klass !== 'function') {
+          const options = klass;
+          klass = options.replace;
+          replace = options.with;
+          replaceWithKlass = options.withKlass || null;
+        }
+        const registeredKlass = initialEditor._nodes.get(klass.getType());
+        initialEditor._nodes.set(klass.getType(), {
+          exportDOM: registeredKlass ? registeredKlass.exportDOM : undefined,
+          klass,
+          replace,
+          replaceWithKlass,
+          transforms: new Set()
+        });
+      }
+    }
+    initialEditor._config.namespace = parentEditor._config.namespace;
+    initialEditor._editable = parentEditor._editable;
+    return [initialEditor, context];
+  },
+  // We only do this for init
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+
+  // If collaboration is enabled, make sure we don't render the children until the collaboration subdocument is ready.
+  const {
+    isCollabActive,
+    yjsDocMap
+  } = useCollaborationContext();
+  const isCollabReady = skipCollabChecks || wasCollabPreviouslyReadyRef.current || yjsDocMap.has(initialEditor.getKey());
+  useEffect(() => {
+    if (isCollabReady) {
+      wasCollabPreviouslyReadyRef.current = true;
+    }
+  }, [isCollabReady]);
+
+  // Update `isEditable` state of nested editor in response to the same change on parent editor.
+  useEffect(() => {
+    return parentEditor.registerEditableListener(editable => {
+      initialEditor.setEditable(editable);
+    });
+  }, [initialEditor, parentEditor]);
+  return /*#__PURE__*/React.createElement(LexicalComposerContext.Provider, {
+    value: composerContext
+  }, !isCollabActive || isCollabReady ? children : null);
+}
+
+export { LexicalNestedComposer };