@lexical/react 0.1.16 → 0.1.17

package/DEPRECATED_useLexicalAutoFormatter.prod.js

@@ -4,22 +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 h=require("@lexical/list"),l=require("lexical"),m=require("lexical/CodeNode"),n=require("react"),p=require("@lexical/react/LexicalHorizontalRuleNode"),q=require("@lexical/text"),r=require("lexical/HeadingNode"),t=require("lexical/QuoteNode");function x(f){throw Error(`Minified Lexical error #${f}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-const y={autoFormatKind:null,regEx:/(?:)/,requiresParagraphStart:!1},z={...y,requiresParagraphStart:!0},A=[{...y,autoFormatKind:"bold_italic",regEx:/(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/},{...y,autoFormatKind:"italic",regEx:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/},{...y,autoFormatKind:"bold",regEx:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/},{...y,autoFormatKind:"bold",regEx:/(__)(\s*)([^__]*)(\s*)(__)(\s)$/},{...y,autoFormatKind:"underline",regEx:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/},
-{...y,autoFormatKind:"strikethrough",regEx:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/},{...y,autoFormatKind:"link",regEx:/(\[)(.+)(\]\()([^ ]+)(?: "(?:.+)")?(\))(\s)$/}],B=[{...z,autoFormatKind:"paragraphH1",regEx:/^(?:# )/},{...z,autoFormatKind:"paragraphH2",regEx:/^(?:## )/},{...z,autoFormatKind:"paragraphH2",regEx:/^(?:### )/},{...z,autoFormatKind:"paragraphBlockQuote",regEx:/^(?:> )/},{...z,autoFormatKind:"paragraphUnorderedList",regEx:/^(?:- )/},{...z,autoFormatKind:"paragraphUnorderedList",regEx:/^(?:\* )/},
-{...z,autoFormatKind:"paragraphOrderedList",regEx:/^(\d+)\.\s/},{...z,autoFormatKind:"paragraphCodeBlock",regEx:/^(```)([a-z]*)( )/},{...z,autoFormatKind:"horizontalRule",regEx:/^(?:\*\*\* )/},{...z,autoFormatKind:"horizontalRule",regEx:/^(?:--- )/},...A];
-function C(f,d,a,b){const c={regExCaptureGroups:[]};b=f.match(b);if(null!==b&&0<b.length&&(!1===d||0===b.index)&&(!1===a||b.index+b[0].length===f.length)){f=b.length;d=b.index;for(a=0;a<f;a++){const e=b[a];c.regExCaptureGroups.push({offsetInParent:d,text:e});0<a&&(d+=e.length)}return c}return null}
-function D(f,d,a,b,c){var e=c.patternMatchResults;const g=e.regExCaptureGroups;var k=g.length;if(f>=k||d>=k)return null;c=c.textNodeWithOffset.node.getParentOrThrow();k=e.regExCaptureGroups.length;2>k?e=0:(--k,e=e.regExCaptureGroups[k].offsetInParent+e.regExCaptureGroups[k].text.length);f=g[f];d=g[d];b=b?d.offsetInParent+d.text.length:d.offsetInParent;a=q.$findNodeWithOffsetFromJoinedText(a?f.offsetInParent+f.text.length:f.offsetInParent,e,1,c);b=q.$findNodeWithOffsetFromJoinedText(b,e,1,c);if(null==
-a||null==b)return null;c=l.$createRangeSelection();c.anchor.set(a.node.getKey(),a.offset,"text");c.focus.set(b.node.getKey(),b.offset,"text");return c}function E(f,d,a){const b=a.patternMatchResults.regExCaptureGroups;a=D(f,d,!1,!0,a);if(null!=a&&(l.$setSelection(a),a=l.$getSelection(),null!=a&&l.$isRangeSelection(a)&&!1===a.isCollapsed())){a.removeText();a=0;const c=b.length;for(let e=f;e<c;e++){const g=b[e];e>f&&(g.offsetInParent-=a);e<=d&&(a+=g.text.length,g.text="")}}}
-function F(f){var d=f.patternMatchResults.regExCaptureGroups.length;2>d||(--d,f=D(d,d,!0,!0,f),null!=f&&l.$setSelection(f))}
-function G(f,d){f.update(()=>{if(d.autoFormatCriteria.requiresParagraphStart){var a=d.textNodeWithOffset,b=a.node.getParentOrThrow();a=a.node.spliceText(0,d.patternMatchResults.regExCaptureGroups[0].text.length,"",!0);""===a.getTextContent()&&(a.selectPrevious(),a.remove());var c=b;a=null;var e=c.getChildren(),g=d.autoFormatCriteria;const k=d.patternMatchResults;if(null!=g.autoFormatKind)switch(g.autoFormatKind){case "paragraphH1":a=r.$createHeadingNode("h1");a.append(...e);break;case "paragraphH2":a=
-r.$createHeadingNode("h2");a.append(...e);break;case "paragraphH3":a=r.$createHeadingNode("h3");a.append(...e);break;case "paragraphBlockQuote":a=t.$createQuoteNode();a.append(...e);break;case "paragraphUnorderedList":a=h.$createListNode("ul");c=h.$createListItemNode();c.append(...e);a.append(c);break;case "paragraphOrderedList":a=parseInt(1<k.regExCaptureGroups.length?k.regExCaptureGroups[k.regExCaptureGroups.length-1].text:"1",10);a=h.$createListNode("ol",a);c=h.$createListItemNode();c.append(...e);
-a.append(c);break;case "paragraphCodeBlock":null!=d.triggerState&&d.triggerState.isCodeBlock?a=l.$createParagraphNode():(a=m.$createCodeNode(),c=3<=k.regExCaptureGroups.length?k.regExCaptureGroups[2].text:null,null!=c&&0<c.length&&a.setLanguage(c));a.append(...e);break;case "horizontalRule":e=p.$createHorizontalRuleNode(),c.insertBefore(e)}null!==a&&b.replace(a)}else if(b=d.autoFormatCriteria,null!=b.autoFormatKind){a:{a=b.autoFormatKind;switch(a){case "italic":case "bold":case "underline":case "strikethrough":a=
-[a];break a;case "bold_italic":a=["bold","italic"];break a}a=null}if(null!=a){if(b=a,7===d.patternMatchResults.regExCaptureGroups.length){E(5,5,d);E(1,1,d);a=d.patternMatchResults.regExCaptureGroups;3<a.length||x(65);if(0!==a[3].text.length&&(a=D(3,3,!1,!0,d),null!=a&&(l.$setSelection(a),a=l.$getSelection(),l.$isRangeSelection(a))))for(e=0;e<b.length;e++)a.formatText(b[e]);F(d)}}else if("link"===b.autoFormatKind&&(b=d.patternMatchResults.regExCaptureGroups,7===b.length&&(e=b[2].text,b=b[4].text,0!==
-e.length&&0!==b.length))){E(1,5,d);a=d.patternMatchResults.regExCaptureGroups;if(!(1>=a.length)&&(e={offsetInParent:a[1].offsetInParent,text:e},c=D(1,1,!1,!1,d),null!=c&&(l.$setSelection(c),c=l.$getSelection(),null!=c&&l.$isRangeSelection(c)&&c.isCollapsed())))for(c.insertText(e.text),a.splice(1,0,e),e=e.text.length,c=a.length,g=2;g<c;g++)a[g].offsetInParent+=e;a=D(1,1,!1,!0,d);null!=a&&(l.$setSelection(a),d.editor.execCommand("toggleLink",b),F(d))}}},{tag:"history-push"})}
-function H(f,d){let a=null;f.getEditorState().read(()=>{var b=l.$getSelection();if(l.$isRangeSelection(b)){var c=b.anchor.getNode();b=l.$isTextNode(c)?{node:c,offset:b.anchor.offset}:null}else b=null;if(null!==b){b={autoFormatCriteria:{autoFormatKind:"noTransformation",regEx:/(?:)/,requiresParagraphStart:null},editor:f,joinedText:null,patternMatchResults:{regExCaptureGroups:[]},textNodeWithOffset:b,triggerState:d};a:{c=!1===d.isParentAListItemNode?B:A;const k=b.triggerState,I=c.length;for(let u=0;u<
-I;u++){const v=c[u];if(null!=k&&!1===k.isCodeBlock||"paragraphCodeBlock"===v.autoFormatKind){var e=v,g=b;if(null!==e.requiresParagraphStart&&!0===e.requiresParagraphStart)null===g.textNodeWithOffset.node.getPreviousSibling()?(g=g.textNodeWithOffset.node.getTextContent(),g=C(g,!0,!1,e.regEx)):g=null;else{if(null==g.joinedText){const w=g.textNodeWithOffset.node.getParentOrThrow();l.$isElementNode(w)?null==g.joinedText&&(g.joinedText=q.$joinTextNodesInElementNode(w,"\u0004",g.textNodeWithOffset)):x(52,
-w.__key)}g=C(g.joinedText,!1,!0,e.regEx)}if(null!=g){c={autoFormatCriteria:v,patternMatchResults:g};break a}}}c={autoFormatCriteria:null,patternMatchResults:null}}null!==c.autoFormatCriteria&&null!==c.patternMatchResults&&(a=b,a.autoFormatCriteria=c.autoFormatCriteria,a.patternMatchResults=c.patternMatchResults)}});return a}
-function J(f){let d=null;f.read(()=>{const a=l.$getSelection();if(l.$isRangeSelection(a)&&a.isCollapsed()){var b=a.anchor.getNode(),c=b.getParent(),e=null!==c&&h.$isListItemNode(c);d={anchorOffset:a.anchor.offset,hasParentNode:null!==c,isCodeBlock:m.$isCodeNode(b),isParentAListItemNode:e,isSelectionCollapsed:a.isCollapsed(),isSimpleText:l.$isTextNode(b)&&b.isSimpleText(),nodeKey:b.getKey(),textContent:b.getTextContent()}}});return d}
-function K(f){n.useEffect(()=>{let d=null;return f.addListener("update",({tags:a})=>{if(!1===a.has("historic")){a=J(f.getEditorState());if(null==a)var b=null;else{b=a;var c=d;if(null==b||null==c)b=null;else{var e=b.textContent.length,g=b.anchorOffset-1;b=!1===(!0===b.hasParentNode&&b.isSimpleText&&b.isSelectionCollapsed&&b.nodeKey===c.nodeKey&&b.anchorOffset!==c.anchorOffset&&0<=g&&g+1<=e&&" "===b.textContent.substr(g,1)&&b.textContent!==c.textContent)?null:H(f,b)}}null!=b&&G(f,b);d=a}else d=null})},
-[f])}module.exports=function(f){K(f)};
+var b=require("@lexical/markdown"),c=require("@lexical/react/LexicalHorizontalRuleNode"),d=require("react");function e(a){d.useEffect(()=>b.registerMarkdownShortcuts(a,c.$createHorizontalRuleNode),[a])}module.exports=function(a){e(a)};

package/DEPRECATED_useLexicalCanShowPlaceholder.dev.js

@@ -41,7 +41,7 @@ var useLayoutEffect = useLayoutEffectImpl;
 function useLexicalCanShowPlaceholder$1(editor) {
   const [canShowPlaceholder, setCanShowPlaceholder] = react.useState(editor.getEditorState().read(text.$canShowPlaceholderCurry(editor.isComposing())));
   useLayoutEffect(() => {
-    return editor.addListener('update', ({
+    return editor.registerUpdateListener(({
       editorState
     }) => {
       const isComposing = editor.isComposing();

package/DEPRECATED_useLexicalCanShowPlaceholder.prod.js

@@ -4,4 +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 b=require("@lexical/text"),d=require("react"),e="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?d.useLayoutEffect:d.useEffect;function f(a){const [g,h]=d.useState(a.getEditorState().read(b.$canShowPlaceholderCurry(a.isComposing())));e(()=>a.addListener("update",({editorState:c})=>{const k=a.isComposing();c=c.read(b.$canShowPlaceholderCurry(k));h(c)}),[a]);return g}module.exports=function(a){return f(a)};
+var b=require("@lexical/text"),d=require("react"),e="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?d.useLayoutEffect:d.useEffect;function f(a){const [g,h]=d.useState(a.getEditorState().read(b.$canShowPlaceholderCurry(a.isComposing())));e(()=>a.registerUpdateListener(({editorState:c})=>{const k=a.isComposing();c=c.read(b.$canShowPlaceholderCurry(k));h(c)}),[a]);return g}module.exports=function(a){return f(a)};

package/DEPRECATED_useLexicalCharacterLimit.dev.js

@@ -6,11 +6,10 @@
  */
 'use strict';
 
-var withSubscriptions = require('@lexical/react/withSubscriptions');
+var overflow = require('@lexical/overflow');
 var text = require('@lexical/text');
 var utils = require('@lexical/utils');
 var lexical = require('lexical');
-var OverflowNode = require('lexical/OverflowNode');
 var react = require('react');
 
 /**
@@ -28,7 +27,7 @@ function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({}))
     remainingCharacters = characters => {}
   } = optional;
   react.useEffect(() => {
-    if (!editor.hasNodes([OverflowNode.OverflowNode])) {
+    if (!editor.hasNodes([overflow.OverflowNode])) {
       {
         throw Error(`useCharacterLimit: OverflowNode not registered on editor`);
       }
@@ -37,9 +36,9 @@ function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({}))
   react.useEffect(() => {
     let text$1 = editor.getEditorState().read(text.$rootTextContentCurry);
     let lastComputedTextLength = 0;
-    return withSubscriptions(editor.addListener('textcontent', currentText => {
+    return utils.mergeRegister(editor.registerTextContentListener(currentText => {
       text$1 = currentText;
-    }), editor.addListener('update', ({
+    }), editor.registerUpdateListener(({
       dirtyLeaves
     }) => {
       const isComposing = editor.isComposing();
@@ -75,7 +74,7 @@ function findOffset(text, maxCharacters, strlen) {
 
   if (typeof Segmenter === 'function') {
     const segmenter = new Segmenter();
-    const graphemes = segmenter.segment(text); // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+    const graphemes = segmenter.segment(text);
 
     for (const {
       segment: grapheme
@@ -119,7 +118,7 @@ function $wrapOverflowedNodes(offset) {
       node
     } = dfsNodes[i];
 
-    if (OverflowNode.$isOverflowNode(node)) {
+    if (overflow.$isOverflowNode(node)) {
       const previousLength = accumulatedLength;
       const nextLength = accumulatedLength + node.getTextContentSize();
 
@@ -156,7 +155,7 @@ function $wrapOverflowedNodes(offset) {
       const previousAccumulatedLength = accumulatedLength;
       accumulatedLength += node.getTextContentSize();
 
-      if (accumulatedLength > offset && !OverflowNode.$isOverflowNode(node.getParent())) {
+      if (accumulatedLength > offset && !overflow.$isOverflowNode(node.getParent())) {
         const previousSelection = lexical.$getSelection();
         let overflowNode; // For simple text we can improve the limit accuracy by splitting the TextNode
         // on the split point
@@ -179,7 +178,7 @@ function $wrapOverflowedNodes(offset) {
 }
 
 function $wrapNode(node) {
-  const overflowNode = OverflowNode.$createOverflowNode();
+  const overflowNode = overflow.$createOverflowNode();
   node.insertBefore(overflowNode);
   overflowNode.append(node);
   return overflowNode;
@@ -200,7 +199,7 @@ function $unwrapNode(node) {
 function mergePrevious(overflowNode) {
   const previousNode = overflowNode.getPreviousSibling();
 
-  if (!OverflowNode.$isOverflowNode(previousNode)) {
+  if (!overflow.$isOverflowNode(previousNode)) {
     return;
   }
 

package/DEPRECATED_useLexicalCharacterLimit.prod.js

@@ -4,10 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var k=require("@lexical/react/withSubscriptions"),q=require("@lexical/text"),w=require("@lexical/utils"),x=require("lexical"),y=require("lexical/OverflowNode"),z=require("react");function B(a,d,f){var e=Intl.Segmenter;let m=0;var c=0;if("function"===typeof e){a=(new e).segment(a);for(var {segment:g}of a){c+=f(g);if(c>d)break;m+=g.length}}else for(g=Array.from(a),a=g.length,e=0;e<a;e++){const n=g[e];c+=f(n);if(c>d)break;m+=n.length}return m}
-function C(a){const d=y.$createOverflowNode();a.insertBefore(d);d.append(a);return d}function D(a){const d=a.getChildren(),f=d.length;for(let e=0;e<f;e++)a.insertBefore(d[e]);a.remove();return 0<f?d[f-1]:null}
-function E(a){const d=a.getPreviousSibling();if(y.$isOverflowNode(d)){var f=a.getFirstChild(),e=d.getChildren(),m=e.length;if(null===f)a.append(...e);else for(var c=0;c<m;c++)f.insertBefore(e[c]);c=x.$getSelection();if(x.$isRangeSelection(c)){f=c.anchor;e=f.getNode();c=c.focus;const g=f.getNode();e.is(d)?f.set(a.getKey(),f.offset,"element"):e.is(a)&&f.set(a.getKey(),m+f.offset,"element");g.is(d)?c.set(a.getKey(),c.offset,"element"):g.is(a)&&c.set(a.getKey(),m+c.offset,"element")}d.remove()}}
-exports.mergePrevious=E;
-exports.useCharacterLimit=function(a,d,f=Object.freeze({})){const {strlen:e=c=>c.length,remainingCharacters:m=()=>{}}=f;z.useEffect(()=>{if(!a.hasNodes([y.OverflowNode]))throw Error("Minified Lexical error #58; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");},[a]);z.useEffect(()=>{let c=a.getEditorState().read(q.$rootTextContentCurry),g=0;return k(a.addListener("textcontent",n=>{c=n}),a.addListener("update",({dirtyLeaves:n})=>
-{var r=a.isComposing();n=0<n.size;if(!r&&n){r=e(c);n=r>d||null!==g&&g>d;m(d-r);if(null===g||n){const p=B(c,d,e);a.update(()=>{const A=w.$dfs(),F=A.length;let t=0;for(let v=0;v<F;v+=1){var {node:b}=A[v];if(y.$isOverflowNode(b)){var l=t;if(t+b.getTextContentSize()<=p){var h=b.getParent();l=b.getPreviousSibling();var u=b.getNextSibling();D(b);b=x.$getSelection();!x.$isRangeSelection(b)||b.anchor.getNode().isAttached()&&b.focus.getNode().isAttached()||(x.$isTextNode(l)?l.select():x.$isTextNode(u)?u.select():
-null!==h&&h.select())}else l<p&&(h=b.getFirstDescendant(),u=null!==h?h.getTextContentSize():0,l+=u,h=x.$isTextNode(h)&&h.isSimpleText(),l=l<=p,(h||l)&&D(b))}else x.$isLeafNode(b)&&(l=t,t+=b.getTextContentSize(),t>p&&!y.$isOverflowNode(b.getParent())&&(h=x.$getSelection(),l<p&&x.$isTextNode(b)&&b.isSimpleText()?([,b]=b.splitText(p-l),b=C(b)):b=C(b),null!==h&&x.$setSelection(h),E(b)))}},{tag:"history-merge"})}g=r}}))},[a,d,m,e])};
+var k=require("@lexical/overflow"),q=require("@lexical/text"),w=require("@lexical/utils"),x=require("lexical"),y=require("react");function z(a,d,f){var e=Intl.Segmenter;let m=0;var c=0;if("function"===typeof e){a=(new e).segment(a);for(var {segment:g}of a){c+=f(g);if(c>d)break;m+=g.length}}else for(g=Array.from(a),a=g.length,e=0;e<a;e++){const n=g[e];c+=f(n);if(c>d)break;m+=n.length}return m}function A(a){const d=k.$createOverflowNode();a.insertBefore(d);d.append(a);return d}
+function C(a){const d=a.getChildren(),f=d.length;for(let e=0;e<f;e++)a.insertBefore(d[e]);a.remove();return 0<f?d[f-1]:null}
+function D(a){const d=a.getPreviousSibling();if(k.$isOverflowNode(d)){var f=a.getFirstChild(),e=d.getChildren(),m=e.length;if(null===f)a.append(...e);else for(var c=0;c<m;c++)f.insertBefore(e[c]);c=x.$getSelection();if(x.$isRangeSelection(c)){f=c.anchor;e=f.getNode();c=c.focus;const g=f.getNode();e.is(d)?f.set(a.getKey(),f.offset,"element"):e.is(a)&&f.set(a.getKey(),m+f.offset,"element");g.is(d)?c.set(a.getKey(),c.offset,"element"):g.is(a)&&c.set(a.getKey(),m+c.offset,"element")}d.remove()}}
+exports.mergePrevious=D;
+exports.useCharacterLimit=function(a,d,f=Object.freeze({})){const {strlen:e=c=>c.length,remainingCharacters:m=()=>{}}=f;y.useEffect(()=>{if(!a.hasNodes([k.OverflowNode]))throw Error("Minified Lexical error #58; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");},[a]);y.useEffect(()=>{let c=a.getEditorState().read(q.$rootTextContentCurry),g=0;return w.mergeRegister(a.registerTextContentListener(n=>{c=n}),a.registerUpdateListener(({dirtyLeaves:n})=>
+{var r=a.isComposing();n=0<n.size;if(!r&&n){r=e(c);n=r>d||null!==g&&g>d;m(d-r);if(null===g||n){const p=z(c,d,e);a.update(()=>{const B=w.$dfs(),E=B.length;let t=0;for(let v=0;v<E;v+=1){var {node:b}=B[v];if(k.$isOverflowNode(b)){var l=t;if(t+b.getTextContentSize()<=p){var h=b.getParent();l=b.getPreviousSibling();var u=b.getNextSibling();C(b);b=x.$getSelection();!x.$isRangeSelection(b)||b.anchor.getNode().isAttached()&&b.focus.getNode().isAttached()||(x.$isTextNode(l)?l.select():x.$isTextNode(u)?u.select():
+null!==h&&h.select())}else l<p&&(h=b.getFirstDescendant(),u=null!==h?h.getTextContentSize():0,l+=u,h=x.$isTextNode(h)&&h.isSimpleText(),l=l<=p,(h||l)&&C(b))}else x.$isLeafNode(b)&&(l=t,t+=b.getTextContentSize(),t>p&&!k.$isOverflowNode(b.getParent())&&(h=x.$getSelection(),l<p&&x.$isTextNode(b)&&b.isSimpleText()?([,b]=b.splitText(p-l),b=A(b)):b=A(b),null!==h&&x.$setSelection(h),D(b)))}},{tag:"history-merge"})}g=r}}))},[a,d,m,e])};

package/DEPRECATED_useLexicalDecorators.dev.js

@@ -42,7 +42,7 @@ function useDecorators(editor) {
   const [decorators, setDecorators] = react.useState(() => editor.getDecorators()); // Subscribe to changes
 
   useLayoutEffect(() => {
-    return editor.addListener('decorator', nextDecorators => {
+    return editor.registerDecoratorListener(nextDecorators => {
       reactDom.flushSync(() => {
         setDecorators(nextDecorators);
       });

package/DEPRECATED_useLexicalDecorators.prod.js

@@ -5,4 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  */
 var c=require("react"),g=require("react-dom"),k="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?c.useLayoutEffect:c.useEffect;
-function l(a){const [e,m]=c.useState(()=>a.getDecorators());k(()=>a.addListener("decorator",d=>{g.flushSync(()=>{m(d)})}),[a]);return c.useMemo(()=>{const d=[],h=Object.keys(e);for(let f=0;f<h.length;f++){var b=h[f];const n=e[b];b=a.getElementByKey(b);null!==b&&d.push(g.createPortal(n,b))}return d},[e,a])}module.exports=function(a){return l(a)};
+function l(a){const [e,m]=c.useState(()=>a.getDecorators());k(()=>a.registerDecoratorListener(d=>{g.flushSync(()=>{m(d)})}),[a]);return c.useMemo(()=>{const d=[],h=Object.keys(e);for(let f=0;f<h.length;f++){var b=h[f];const n=e[b];b=a.getElementByKey(b);null!==b&&d.push(g.createPortal(n,b))}return d},[e,a])}module.exports=function(a){return l(a)};

package/DEPRECATED_useLexicalEditorEvents.dev.js

@@ -69,7 +69,7 @@ function useEditorEvents(events, editor) {
       });
     }
 
-    return editor.addListener('root', (rootElement, prevRootElement) => {
+    return editor.registerRootListener((rootElement, prevRootElement) => {
       if (prevRootElement !== null) {
         destroy.forEach(fn => fn(prevRootElement));
       }

package/DEPRECATED_useLexicalEditorEvents.prod.js

@@ -5,4 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  */
 var g=require("react"),h="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?g.useLayoutEffect:g.useEffect;function p(a,b){return"selectionchange"===a||"keyup"===a||"pointerup"===a||"pointercancel"===a?b.ownerDocument:b}
-function q(a,b){h(()=>{const k=[],l=[];for(let d=0;d<a.length;d++){const [c,e]=a[d],n=f=>{const m=b.getRootElement();null!==m&&"true"===m.contentEditable&&e(f,b)};k.push(f=>{p(c,f).addEventListener(c,n)});l.push(f=>{p(c,f).removeEventListener(c,n)})}return b.addListener("root",(d,c)=>{null!==c&&l.forEach(e=>e(c));null!==d&&k.forEach(e=>e(d))})},[b,a])}module.exports=function(a,b){q(a,b)};
+function q(a,b){h(()=>{const k=[],l=[];for(let d=0;d<a.length;d++){const [c,e]=a[d],n=f=>{const m=b.getRootElement();null!==m&&"true"===m.contentEditable&&e(f,b)};k.push(f=>{p(c,f).addEventListener(c,n)});l.push(f=>{p(c,f).removeEventListener(c,n)})}return b.registerRootListener((d,c)=>{null!==c&&l.forEach(e=>e(c));null!==d&&k.forEach(e=>e(d))})},[b,a])}module.exports=function(a,b){q(a,b)};

package/DEPRECATED_useLexicalHistory.dev.js

@@ -6,8 +6,7 @@
  */
 'use strict';
 
-var withSubscriptions = require('@lexical/react/withSubscriptions');
-var lexical = require('lexical');
+var history = require('@lexical/history');
 var react = require('react');
 
 /**
@@ -18,312 +17,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]);
 }
 
 /**
@@ -338,5 +36,5 @@ function useLexicalHistory(editor, externalHistoryState, delay = 1000) {
   return useHistory(editor, externalHistoryState, delay);
 }
 
-exports.createEmptyHistoryState = createEmptyHistoryState;
+exports.createEmptyHistoryState = history.createEmptyHistoryState;
 exports.useLexicalHistory = useLexicalHistory;

package/DEPRECATED_useLexicalHistory.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/withSubscriptions"),t=require("lexical"),v=require("react");
-function w(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(!(t.$isRangeSelection(g)&&t.$isRangeSelection(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||t.$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)&&t.$isTextNode(d)&&1===d.__text.length&&1===g.anchor.offset?2:0;d=h[0];b=b._nodeMap.get(d.__key);if(!t.$isTextNode(b)||!t.$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 x(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=w(h,g,e,f,b.isComposing()),u=(()=>{const r=l.has("history-push");if(!r&&l.has("history-merge"))return 0;if(null===h)return 1;var q=g._selection;const z=h._selection;if(!(0<e.size||0<f.size))return null===z&&null!==q?0:2;q=null===c||c.editor===b;return!1===r&&0!==m&&m===a&&p<k+d&&q?0:1})();k=p;a=m;return u}}
-function y(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=x(b,k);return n(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,r=a.undoStack,q=null===m?null:m.editorState;if(null===m||
-c!==q){f=g(e,c,m,f,l,p);if(1===f)0!==u.length&&(a.redoStack=[]),null!==m&&(r.push({...m,undoSelection:e.read(t.$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.createEmptyHistoryState=A;exports.useLexicalHistory=function(b,d,k=1E3){return y(b,d,k)};
+var d=require("@lexical/history"),e=require("react");function g(a,b,c=1E3){const f=e.useMemo(()=>b||d.createEmptyHistoryState(),[b]);e.useEffect(()=>d.registerHistory(a,f,c),[c,a,f])}exports.createEmptyHistoryState=d.createEmptyHistoryState;exports.useLexicalHistory=function(a,b,c=1E3){return g(a,b,c)};

package/DEPRECATED_useLexicalList.dev.js

@@ -7,6 +7,8 @@
 'use strict';
 
 var list = require('@lexical/list');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
 var react = require('react');
 
 /**
@@ -20,38 +22,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/DEPRECATED_useLexicalList.prod.js

@@ -4,4 +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/list"),d=require("react");function e(a){d.useEffect(()=>a.addListener("command",c=>{if("indentContent"===c){if(b.indentList())return!0}else if("outdentContent"===c){if(b.outdentList())return!0}else{if("insertOrderedList"===c)return b.insertList(a,"ol"),!0;if("insertUnorderedList"===c)return b.insertList(a,"ul"),!0;if("removeList"===c)return b.removeList(a),!0;if("insertParagraph"===c&&b.$handleListInsertParagraph())return!0}return!1},1),[a])}module.exports=function(a){e(a)};
+var b=require("@lexical/list"),c=require("@lexical/utils"),d=require("lexical"),e=require("react");
+function f(a){e.useEffect(()=>c.mergeRegister(a.registerCommand(d.INDENT_CONTENT_COMMAND,()=>b.indentList()?!0:!1,1),a.registerCommand(d.OUTDENT_CONTENT_COMMAND,()=>b.outdentList()?!0:!1,1),a.registerCommand(b.INSERT_ORDERED_LIST_COMMAND,()=>{b.insertList(a,"ol");return!0},1),a.registerCommand(b.INSERT_UNORDERED_LIST_COMMAND,()=>{b.insertList(a,"ul");return!0},1),a.registerCommand(b.REMOVE_LIST_COMMAND,()=>{b.removeList(a);return!0},1),a.registerCommand(d.INSERT_PARAGRAPH_COMMAND,()=>b.$handleListInsertParagraph()?
+!0:!1,1)),[a])}module.exports=function(a){f(a)};