@lexical/react 0.13.1 → 0.14.1

package/LexicalBlockWithAlignableContents.dev.esm.js

@@ -0,0 +1,86 @@
+/**
+ * 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 { $isDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { mergeRegister, $getNearestBlockElementAncestorOrThrow } from '@lexical/utils';
+import { $isNodeSelection, $getSelection, $getNodeByKey, $isDecoratorNode, FORMAT_ELEMENT_COMMAND, $isRangeSelection, COMMAND_PRIORITY_LOW, CLICK_COMMAND, KEY_DELETE_COMMAND, KEY_BACKSPACE_COMMAND } from 'lexical';
+import * as React from 'react';
+import { useRef, 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.
+ *
+ */
+function BlockWithAlignableContents({
+  children,
+  format,
+  nodeKey,
+  className
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+  const ref = useRef(null);
+  const onDelete = useCallback(event => {
+    if (isSelected && $isNodeSelection($getSelection())) {
+      event.preventDefault();
+      const node = $getNodeByKey(nodeKey);
+      if ($isDecoratorNode(node)) {
+        node.remove();
+        return true;
+      }
+    }
+    return false;
+  }, [isSelected, nodeKey]);
+  useEffect(() => {
+    return mergeRegister(editor.registerCommand(FORMAT_ELEMENT_COMMAND, formatType => {
+      if (isSelected) {
+        const selection = $getSelection();
+        if ($isNodeSelection(selection)) {
+          const node = $getNodeByKey(nodeKey);
+          if ($isDecoratorBlockNode(node)) {
+            node.setFormat(formatType);
+          }
+        } else if ($isRangeSelection(selection)) {
+          const nodes = selection.getNodes();
+          for (const node of nodes) {
+            if ($isDecoratorBlockNode(node)) {
+              node.setFormat(formatType);
+            } else {
+              const element = $getNearestBlockElementAncestorOrThrow(node);
+              element.setFormat(formatType);
+            }
+          }
+        }
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW), editor.registerCommand(CLICK_COMMAND, event => {
+      if (event.target === ref.current) {
+        event.preventDefault();
+        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]);
+  return /*#__PURE__*/React.createElement("div", {
+    className: [className.base, isSelected ? className.focus : null].filter(Boolean).join(' '),
+    ref: ref,
+    style: {
+      textAlign: format ? format : undefined
+    }
+  }, children);
+}
+
+export { BlockWithAlignableContents };

package/LexicalBlockWithAlignableContents.dev.js

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

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

package/LexicalBlockWithAlignableContents.js

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

package/LexicalBlockWithAlignableContents.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{$isDecoratorBlockNode as r}from"@lexical/react/LexicalDecoratorBlockNode";import{useLexicalNodeSelection as t}from"@lexical/react/useLexicalNodeSelection";import{mergeRegister as o,$getNearestBlockElementAncestorOrThrow as i}from"@lexical/utils";import{$isNodeSelection as a,$getSelection as l,$getNodeByKey as m,$isDecoratorNode as n,FORMAT_ELEMENT_COMMAND as c,$isRangeSelection as s,COMMAND_PRIORITY_LOW as f,CLICK_COMMAND as u,KEY_DELETE_COMMAND as d,KEY_BACKSPACE_COMMAND as p}from"lexical";import*as x from"react";import{useRef as g,useCallback as C,useEffect as v}from"react";function N({children:N,format:y,nodeKey:D,className:F}){const[L]=e(),[h,B,K]=t(D),b=g(null),j=C((e=>{if(h&&a(l())){e.preventDefault();const r=m(D);if(n(r))return r.remove(),!0}return!1}),[h,D]);return v((()=>o(L.registerCommand(c,(e=>{if(h){const t=l();if(a(t)){const t=m(D);r(t)&&t.setFormat(e)}else if(s(t)){const o=t.getNodes();for(const t of o)if(r(t))t.setFormat(e);else{i(t).setFormat(e)}}return!0}return!1}),f),L.registerCommand(u,(e=>e.target===b.current&&(e.preventDefault(),e.shiftKey||K(),B(!h),!0)),f),L.registerCommand(d,j,f),L.registerCommand(p,j,f))),[K,L,h,D,j,B]),x.createElement("div",{className:[F.base,h?F.focus:null].filter(Boolean).join(" "),ref:b,style:{textAlign:y||void 0}},N)}export{N as BlockWithAlignableContents};

package/LexicalBlockWithAlignableContents.prod.js

@@ -5,6 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict';var a=require("@lexical/react/LexicalComposerContext"),h=require("@lexical/react/LexicalDecoratorBlockNode"),l=require("@lexical/react/useLexicalNodeSelection"),m=require("@lexical/utils"),u=require("lexical"),v=require("react");
-exports.BlockWithAlignableContents=function({children:w,format:n,nodeKey:e,className:p}){let [f]=a.useLexicalComposerContext(),[c,q,r]=l.useLexicalNodeSelection(e),t=v.useRef(null),k=v.useCallback(b=>{c&&u.$isNodeSelection(u.$getSelection())&&(b.preventDefault(),b=u.$getNodeByKey(e),u.$isDecoratorNode(b)&&b.remove());return!1},[c,e]);v.useEffect(()=>m.mergeRegister(f.registerCommand(u.FORMAT_ELEMENT_COMMAND,b=>{if(c){var g=u.$getSelection();if(u.$isNodeSelection(g)){var d=u.$getNodeByKey(e);h.$isDecoratorBlockNode(d)&&
+exports.BlockWithAlignableContents=function({children:w,format:n,nodeKey:e,className:p}){let [f]=a.useLexicalComposerContext(),[c,q,r]=l.useLexicalNodeSelection(e),t=v.useRef(null),k=v.useCallback(b=>c&&u.$isNodeSelection(u.$getSelection())&&(b.preventDefault(),b=u.$getNodeByKey(e),u.$isDecoratorNode(b))?(b.remove(),!0):!1,[c,e]);v.useEffect(()=>m.mergeRegister(f.registerCommand(u.FORMAT_ELEMENT_COMMAND,b=>{if(c){var g=u.$getSelection();if(u.$isNodeSelection(g)){var d=u.$getNodeByKey(e);h.$isDecoratorBlockNode(d)&&
 d.setFormat(b)}else if(u.$isRangeSelection(g)){g=g.getNodes();for(d of g)h.$isDecoratorBlockNode(d)?d.setFormat(b):m.$getNearestBlockElementAncestorOrThrow(d).setFormat(b)}return!0}return!1},u.COMMAND_PRIORITY_LOW),f.registerCommand(u.CLICK_COMMAND,b=>b.target===t.current?(b.preventDefault(),b.shiftKey||r(),q(!c),!0):!1,u.COMMAND_PRIORITY_LOW),f.registerCommand(u.KEY_DELETE_COMMAND,k,u.COMMAND_PRIORITY_LOW),f.registerCommand(u.KEY_BACKSPACE_COMMAND,k,u.COMMAND_PRIORITY_LOW)),[r,f,c,e,k,q]);return v.createElement("div",
 {className:[p.base,c?p.focus:null].filter(Boolean).join(" "),ref:t,style:{textAlign:n?n:void 0}},w)}

package/LexicalCharacterLimitPlugin.d.ts

@@ -6,7 +6,10 @@
  *
  */
 /// <reference types="react" />
-export declare function CharacterLimitPlugin({ charset, maxLength, }: {
+export declare function CharacterLimitPlugin({ charset, maxLength, renderer, }: {
     charset: 'UTF-8' | 'UTF-16';
     maxLength: number;
+    renderer?: ({ remainingCharacters, }: {
+        remainingCharacters: number;
+    }) => JSX.Element;
 }): JSX.Element;

package/LexicalCharacterLimitPlugin.dev.esm.js

@@ -0,0 +1,272 @@
+/**
+ * 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 * as React from 'react';
+import { useEffect, useState, useMemo } from 'react';
+import { OverflowNode, $isOverflowNode, $createOverflowNode } from '@lexical/overflow';
+import { $rootTextContent } from '@lexical/text';
+import { mergeRegister, $dfs } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, $isTextNode, $isLeafNode, $setSelection } 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 useCharacterLimit(editor, maxCharacters, optional = Object.freeze({})) {
+  const {
+    strlen = input => input.length,
+    // UTF-16
+    remainingCharacters = () => {
+      return;
+    }
+  } = optional;
+  useEffect(() => {
+    if (!editor.hasNodes([OverflowNode])) {
+      {
+        throw Error(`useCharacterLimit: OverflowNode not registered on editor`);
+      }
+    }
+  }, [editor]);
+  useEffect(() => {
+    let text = editor.getEditorState().read($rootTextContent);
+    let lastComputedTextLength = 0;
+    return mergeRegister(editor.registerTextContentListener(currentText => {
+      text = currentText;
+    }), editor.registerUpdateListener(({
+      dirtyLeaves,
+      dirtyElements
+    }) => {
+      const isComposing = editor.isComposing();
+      const hasContentChanges = dirtyLeaves.size > 0 || dirtyElements.size > 0;
+      if (isComposing || !hasContentChanges) {
+        return;
+      }
+      const textLength = strlen(text);
+      const textLengthAboveThreshold = textLength > maxCharacters || lastComputedTextLength !== null && lastComputedTextLength > maxCharacters;
+      const diff = maxCharacters - textLength;
+      remainingCharacters(diff);
+      if (lastComputedTextLength === null || textLengthAboveThreshold) {
+        const offset = findOffset(text, maxCharacters, strlen);
+        editor.update(() => {
+          $wrapOverflowedNodes(offset);
+        }, {
+          tag: 'history-merge'
+        });
+      }
+      lastComputedTextLength = textLength;
+    }));
+  }, [editor, maxCharacters, remainingCharacters, strlen]);
+}
+function findOffset(text, maxCharacters, strlen) {
+  // @ts-ignore This is due to be added in a later version of TS
+  const Segmenter = Intl.Segmenter;
+  let offsetUtf16 = 0;
+  let offset = 0;
+  if (typeof Segmenter === 'function') {
+    const segmenter = new Segmenter();
+    const graphemes = segmenter.segment(text);
+    for (const {
+      segment: grapheme
+    } of graphemes) {
+      const nextOffset = offset + strlen(grapheme);
+      if (nextOffset > maxCharacters) {
+        break;
+      }
+      offset = nextOffset;
+      offsetUtf16 += grapheme.length;
+    }
+  } else {
+    const codepoints = Array.from(text);
+    const codepointsLength = codepoints.length;
+    for (let i = 0; i < codepointsLength; i++) {
+      const codepoint = codepoints[i];
+      const nextOffset = offset + strlen(codepoint);
+      if (nextOffset > maxCharacters) {
+        break;
+      }
+      offset = nextOffset;
+      offsetUtf16 += codepoint.length;
+    }
+  }
+  return offsetUtf16;
+}
+function $wrapOverflowedNodes(offset) {
+  const dfsNodes = $dfs();
+  const dfsNodesLength = dfsNodes.length;
+  let accumulatedLength = 0;
+  for (let i = 0; i < dfsNodesLength; i += 1) {
+    const {
+      node
+    } = dfsNodes[i];
+    if ($isOverflowNode(node)) {
+      const previousLength = accumulatedLength;
+      const nextLength = accumulatedLength + node.getTextContentSize();
+      if (nextLength <= offset) {
+        const parent = node.getParent();
+        const previousSibling = node.getPreviousSibling();
+        const nextSibling = node.getNextSibling();
+        $unwrapNode(node);
+        const selection = $getSelection();
+
+        // Restore selection when the overflow children are removed
+        if ($isRangeSelection(selection) && (!selection.anchor.getNode().isAttached() || !selection.focus.getNode().isAttached())) {
+          if ($isTextNode(previousSibling)) {
+            previousSibling.select();
+          } else if ($isTextNode(nextSibling)) {
+            nextSibling.select();
+          } else if (parent !== null) {
+            parent.select();
+          }
+        }
+      } else if (previousLength < offset) {
+        const descendant = node.getFirstDescendant();
+        const descendantLength = descendant !== null ? descendant.getTextContentSize() : 0;
+        const previousPlusDescendantLength = previousLength + descendantLength;
+        // For simple text we can redimension the overflow into a smaller and more accurate
+        // container
+        const firstDescendantIsSimpleText = $isTextNode(descendant) && descendant.isSimpleText();
+        const firstDescendantDoesNotOverflow = previousPlusDescendantLength <= offset;
+        if (firstDescendantIsSimpleText || firstDescendantDoesNotOverflow) {
+          $unwrapNode(node);
+        }
+      }
+    } else if ($isLeafNode(node)) {
+      const previousAccumulatedLength = accumulatedLength;
+      accumulatedLength += node.getTextContentSize();
+      if (accumulatedLength > offset && !$isOverflowNode(node.getParent())) {
+        const previousSelection = $getSelection();
+        let overflowNode;
+
+        // For simple text we can improve the limit accuracy by splitting the TextNode
+        // on the split point
+        if (previousAccumulatedLength < offset && $isTextNode(node) && node.isSimpleText()) {
+          const [, overflowedText] = node.splitText(offset - previousAccumulatedLength);
+          overflowNode = $wrapNode(overflowedText);
+        } else {
+          overflowNode = $wrapNode(node);
+        }
+        if (previousSelection !== null) {
+          $setSelection(previousSelection);
+        }
+        mergePrevious(overflowNode);
+      }
+    }
+  }
+}
+function $wrapNode(node) {
+  const overflowNode = $createOverflowNode();
+  node.insertBefore(overflowNode);
+  overflowNode.append(node);
+  return overflowNode;
+}
+function $unwrapNode(node) {
+  const children = node.getChildren();
+  const childrenLength = children.length;
+  for (let i = 0; i < childrenLength; i++) {
+    node.insertBefore(children[i]);
+  }
+  node.remove();
+  return childrenLength > 0 ? children[childrenLength - 1] : null;
+}
+function mergePrevious(overflowNode) {
+  const previousNode = overflowNode.getPreviousSibling();
+  if (!$isOverflowNode(previousNode)) {
+    return;
+  }
+  const firstChild = overflowNode.getFirstChild();
+  const previousNodeChildren = previousNode.getChildren();
+  const previousNodeChildrenLength = previousNodeChildren.length;
+  if (firstChild === null) {
+    overflowNode.append(...previousNodeChildren);
+  } else {
+    for (let i = 0; i < previousNodeChildrenLength; i++) {
+      firstChild.insertBefore(previousNodeChildren[i]);
+    }
+  }
+  const selection = $getSelection();
+  if ($isRangeSelection(selection)) {
+    const anchor = selection.anchor;
+    const anchorNode = anchor.getNode();
+    const focus = selection.focus;
+    const focusNode = anchor.getNode();
+    if (anchorNode.is(previousNode)) {
+      anchor.set(overflowNode.getKey(), anchor.offset, 'element');
+    } else if (anchorNode.is(overflowNode)) {
+      anchor.set(overflowNode.getKey(), previousNodeChildrenLength + anchor.offset, 'element');
+    }
+    if (focusNode.is(previousNode)) {
+      focus.set(overflowNode.getKey(), focus.offset, 'element');
+    } else if (focusNode.is(overflowNode)) {
+      focus.set(overflowNode.getKey(), previousNodeChildrenLength + focus.offset, 'element');
+    }
+  }
+  previousNode.remove();
+}
+
+/**
+ * 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 CHARACTER_LIMIT = 5;
+let textEncoderInstance = null;
+function textEncoder() {
+  if (window.TextEncoder === undefined) {
+    return null;
+  }
+  if (textEncoderInstance === null) {
+    textEncoderInstance = new window.TextEncoder();
+  }
+  return textEncoderInstance;
+}
+function utf8Length(text) {
+  const currentTextEncoder = textEncoder();
+  if (currentTextEncoder === null) {
+    // http://stackoverflow.com/a/5515960/210370
+    const m = encodeURIComponent(text).match(/%[89ABab]/g);
+    return text.length + (m ? m.length : 0);
+  }
+  return currentTextEncoder.encode(text).length;
+}
+function DefaultRenderer({
+  remainingCharacters
+}) {
+  return /*#__PURE__*/React.createElement("span", {
+    className: `characters-limit ${remainingCharacters < 0 ? 'characters-limit-exceeded' : ''}`
+  }, remainingCharacters);
+}
+function CharacterLimitPlugin({
+  charset = 'UTF-16',
+  maxLength = CHARACTER_LIMIT,
+  renderer = DefaultRenderer
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [remainingCharacters, setRemainingCharacters] = useState(maxLength);
+  const characterLimitProps = useMemo(() => ({
+    remainingCharacters: setRemainingCharacters,
+    strlen: text => {
+      if (charset === 'UTF-8') {
+        return utf8Length(text);
+      } else if (charset === 'UTF-16') {
+        return text.length;
+      } else {
+        throw new Error('Unrecognized charset');
+      }
+    }
+  }), [charset]);
+  useCharacterLimit(editor, maxLength, characterLimitProps);
+  return renderer({
+    remainingCharacters
+  });
+}
+
+export { CharacterLimitPlugin };

package/LexicalCharacterLimitPlugin.dev.js

@@ -238,9 +238,17 @@ function utf8Length(text) {
   }
   return currentTextEncoder.encode(text).length;
 }
+function DefaultRenderer({
+  remainingCharacters
+}) {
+  return /*#__PURE__*/React.createElement("span", {
+    className: `characters-limit ${remainingCharacters < 0 ? 'characters-limit-exceeded' : ''}`
+  }, remainingCharacters);
+}
 function CharacterLimitPlugin({
   charset = 'UTF-16',
-  maxLength = CHARACTER_LIMIT
+  maxLength = CHARACTER_LIMIT,
+  renderer = DefaultRenderer
 }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const [remainingCharacters, setRemainingCharacters] = React.useState(maxLength);
@@ -257,9 +265,9 @@ function CharacterLimitPlugin({
     }
   }), [charset]);
   useCharacterLimit(editor, maxLength, characterLimitProps);
-  return /*#__PURE__*/React.createElement("span", {
-    className: `characters-limit ${remainingCharacters < 0 ? 'characters-limit-exceeded' : ''}`
-  }, remainingCharacters);
+  return renderer({
+    remainingCharacters
+  });
 }
 
 exports.CharacterLimitPlugin = CharacterLimitPlugin;

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

package/LexicalCharacterLimitPlugin.js

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

package/LexicalCharacterLimitPlugin.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*as t from"react";import{useEffect as n,useState as r,useMemo as o}from"react";import{OverflowNode as i,$isOverflowNode as s,$createOverflowNode as l}from"@lexical/overflow";import{$rootTextContent as c}from"@lexical/text";import{mergeRegister as a,$dfs as f}from"@lexical/utils";import{$getSelection as g,$isRangeSelection as m,$isTextNode as u,$isLeafNode as d,$setSelection as h}from"lexical";var p=function(e){const t=new URLSearchParams;t.append("code",e);for(let e=1;e<arguments.length;e++)t.append("v",arguments[e]);throw Error(`Minified Lexical error #${e}; visit https://lexical.dev/docs/error?${t} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)};function x(e,t,r=Object.freeze({})){const{strlen:o=(e=>e.length),remainingCharacters:l=(()=>{})}=r;n((()=>{e.hasNodes([i])||p(57)}),[e]),n((()=>{let n=e.getEditorState().read(c),r=0;return a(e.registerTextContentListener((e=>{n=e})),e.registerUpdateListener((({dirtyLeaves:i,dirtyElements:c})=>{const a=e.isComposing(),p=i.size>0||c.size>0;if(a||!p)return;const x=o(n),T=x>t||null!==r&&r>t;if(l(t-x),null===r||T){const r=function(e,t,n){const r=Intl.Segmenter;let o=0,i=0;if("function"==typeof r){const s=(new r).segment(e);for(const{segment:e}of s){const r=i+n(e);if(r>t)break;i=r,o+=e.length}}else{const r=Array.from(e),s=r.length;for(let e=0;e<s;e++){const s=r[e],l=i+n(s);if(l>t)break;i=l,o+=s.length}}return o}(n,t,o);e.update((()=>{!function(e){const t=f(),n=t.length;let r=0;for(let o=0;o<n;o+=1){const{node:n}=t[o];if(s(n)){const t=r;if(r+n.getTextContentSize()<=e){const e=n.getParent(),t=n.getPreviousSibling(),r=n.getNextSibling();v(n);const o=g();!m(o)||o.anchor.getNode().isAttached()&&o.focus.getNode().isAttached()||(u(t)?t.select():u(r)?r.select():null!==e&&e.select())}else if(t<e){const r=n.getFirstDescendant(),o=t+(null!==r?r.getTextContentSize():0);(u(r)&&r.isSimpleText()||o<=e)&&v(n)}}else if(d(n)){const t=r;if(r+=n.getTextContentSize(),r>e&&!s(n.getParent())){const r=g();let o;if(t<e&&u(n)&&n.isSimpleText()){const[,r]=n.splitText(e-t);o=C(r)}else o=C(n);null!==r&&h(r),w(o)}}}}(r)}),{tag:"history-merge"})}r=x})))}),[e,t,l,o])}function C(e){const t=l();return e.insertBefore(t),t.append(e),t}function v(e){const t=e.getChildren(),n=t.length;for(let r=0;r<n;r++)e.insertBefore(t[r]);return e.remove(),n>0?t[n-1]:null}function w(e){const t=e.getPreviousSibling();if(!s(t))return;const n=e.getFirstChild(),r=t.getChildren(),o=r.length;if(null===n)e.append(...r);else for(let e=0;e<o;e++)n.insertBefore(r[e]);const i=g();if(m(i)){const n=i.anchor,r=n.getNode(),s=i.focus,l=n.getNode();r.is(t)?n.set(e.getKey(),n.offset,"element"):r.is(e)&&n.set(e.getKey(),o+n.offset,"element"),l.is(t)?s.set(e.getKey(),s.offset,"element"):l.is(e)&&s.set(e.getKey(),o+s.offset,"element")}t.remove()}let T=null;function S(e){const t=void 0===window.TextEncoder?null:(null===T&&(T=new window.TextEncoder),T);if(null===t){const t=encodeURIComponent(e).match(/%[89ABab]/g);return e.length+(t?t.length:0)}return t.encode(e).length}function y({remainingCharacters:e}){return t.createElement("span",{className:"characters-limit "+(e<0?"characters-limit-exceeded":"")},e)}function b({charset:t="UTF-16",maxLength:n=5,renderer:i=y}){const[s]=e(),[l,c]=r(n);return x(s,n,o((()=>({remainingCharacters:c,strlen:e=>{if("UTF-8"===t)return S(e);if("UTF-16"===t)return e.length;throw new Error("Unrecognized charset")}})),[t])),i({remainingCharacters:l})}export{b as CharacterLimitPlugin};

package/LexicalCharacterLimitPlugin.prod.js

@@ -4,12 +4,12 @@
  * 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 p=require("@lexical/react/LexicalComposerContext"),u=require("react"),v=require("@lexical/overflow"),z=require("@lexical/text"),A=require("@lexical/utils"),C=require("lexical");
-function D(b){let c=new URLSearchParams;c.append("code",b);for(let k=1;k<arguments.length;k++)c.append("v",arguments[k]);throw Error(`Minified Lexical error #${b}; visit https://lexical.dev/docs/error?${c} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-function F(b,c,k=Object.freeze({})){let {strlen:e=m=>m.length,remainingCharacters:q=()=>{}}=k;u.useEffect(()=>{b.hasNodes([v.OverflowNode])||D(57)},[b]);u.useEffect(()=>{let m=b.getEditorState().read(z.$rootTextContent),d=0;return A.mergeRegister(b.registerTextContentListener(f=>{m=f}),b.registerUpdateListener(({dirtyLeaves:f,dirtyElements:J})=>{var w=b.isComposing();f=0<f.size||0<J.size;if(!w&&f){w=e(m);f=w>c||null!==d&&d>c;q(c-w);if(null===d||f){let r=G(m,c,e);b.update(()=>{let B=A.$dfs(),L=B.length,
-x=0;for(let y=0;y<L;y+=1){var {node:a}=B[y];if(v.$isOverflowNode(a)){var g=x;if(x+a.getTextContentSize()<=r){var h=a.getParent();g=a.getPreviousSibling();var l=a.getNextSibling();H(a);a=C.$getSelection();!C.$isRangeSelection(a)||a.anchor.getNode().isAttached()&&a.focus.getNode().isAttached()||(C.$isTextNode(g)?g.select():C.$isTextNode(l)?l.select():null!==h&&h.select())}else g<r&&(h=a.getFirstDescendant(),l=null!==h?h.getTextContentSize():0,g+=l,h=C.$isTextNode(h)&&h.isSimpleText(),g=g<=r,(h||g)&&
-H(a))}else if(C.$isLeafNode(a)&&(g=x,x+=a.getTextContentSize(),x>r&&!v.$isOverflowNode(a.getParent())&&(h=C.$getSelection(),g<r&&C.$isTextNode(a)&&a.isSimpleText()?([,a]=a.splitText(r-g),a=I(a)):a=I(a),null!==h&&C.$setSelection(h),g=a.getPreviousSibling(),v.$isOverflowNode(g)))){l=a.getFirstChild();var t=g.getChildren();h=t.length;if(null===l)a.append(...t);else for(var n=0;n<h;n++)l.insertBefore(t[n]);n=C.$getSelection();if(C.$isRangeSelection(n)){l=n.anchor;t=l.getNode();n=n.focus;let E=l.getNode();
-t.is(g)?l.set(a.getKey(),l.offset,"element"):t.is(a)&&l.set(a.getKey(),h+l.offset,"element");E.is(g)?n.set(a.getKey(),n.offset,"element"):E.is(a)&&n.set(a.getKey(),h+n.offset,"element")}g.remove()}}},{tag:"history-merge"})}d=w}}))},[b,c,q,e])}
-function G(b,c,k){var e=Intl.Segmenter;let q=0;var m=0;if("function"===typeof e){b=(new e).segment(b);for(var {segment:d}of b){m+=k(d);if(m>c)break;q+=d.length}}else for(d=Array.from(b),b=d.length,e=0;e<b;e++){let f=d[e];m+=k(f);if(m>c)break;q+=f.length}return q}function I(b){let c=v.$createOverflowNode();b.insertBefore(c);c.append(b);return c}function H(b){let c=b.getChildren(),k=c.length;for(let e=0;e<k;e++)b.insertBefore(c[e]);b.remove();return 0<k?c[k-1]:null}let K=null;
-exports.CharacterLimitPlugin=function({charset:b="UTF-16",maxLength:c=5}){let [k]=p.useLexicalComposerContext(),[e,q]=u.useState(c),m=u.useMemo(()=>({remainingCharacters:q,strlen:d=>{if("UTF-8"===b){if(void 0===window.TextEncoder)var f=null;else null===K&&(K=new window.TextEncoder),f=K;null===f?(f=encodeURIComponent(d).match(/%[89ABab]/g),d=d.length+(f?f.length:0)):d=f.encode(d).length;return d}if("UTF-16"===b)return d.length;throw Error("Unrecognized charset");}}),[b]);F(k,c,m);return u.createElement("span",
-{className:`characters-limit ${0>e?"characters-limit-exceeded":""}`},e)}
+'use strict';var p=require("@lexical/react/LexicalComposerContext"),v=require("react"),w=require("@lexical/overflow"),A=require("@lexical/text"),B=require("@lexical/utils"),D=require("lexical");
+function E(a){let c=new URLSearchParams;c.append("code",a);for(let h=1;h<arguments.length;h++)c.append("v",arguments[h]);throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?${c} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
+function G(a,c,h=Object.freeze({})){let {strlen:f=l=>l.length,remainingCharacters:q=()=>{}}=h;v.useEffect(()=>{a.hasNodes([w.OverflowNode])||E(57)},[a]);v.useEffect(()=>{let l=a.getEditorState().read(A.$rootTextContent),m=0;return B.mergeRegister(a.registerTextContentListener(d=>{l=d}),a.registerUpdateListener(({dirtyLeaves:d,dirtyElements:r})=>{var x=a.isComposing();d=0<d.size||0<r.size;if(!x&&d){x=f(l);d=x>c||null!==m&&m>c;q(c-x);if(null===m||d){let t=H(l,c,f);a.update(()=>{let C=B.$dfs(),L=C.length,
+y=0;for(let z=0;z<L;z+=1){var {node:b}=C[z];if(w.$isOverflowNode(b)){var e=y;if(y+b.getTextContentSize()<=t){var g=b.getParent();e=b.getPreviousSibling();var k=b.getNextSibling();I(b);b=D.$getSelection();!D.$isRangeSelection(b)||b.anchor.getNode().isAttached()&&b.focus.getNode().isAttached()||(D.$isTextNode(e)?e.select():D.$isTextNode(k)?k.select():null!==g&&g.select())}else e<t&&(g=b.getFirstDescendant(),k=null!==g?g.getTextContentSize():0,e+=k,g=D.$isTextNode(g)&&g.isSimpleText(),e=e<=t,(g||e)&&
+I(b))}else if(D.$isLeafNode(b)&&(e=y,y+=b.getTextContentSize(),y>t&&!w.$isOverflowNode(b.getParent())&&(g=D.$getSelection(),e<t&&D.$isTextNode(b)&&b.isSimpleText()?([,b]=b.splitText(t-e),b=J(b)):b=J(b),null!==g&&D.$setSelection(g),e=b.getPreviousSibling(),w.$isOverflowNode(e)))){k=b.getFirstChild();var u=e.getChildren();g=u.length;if(null===k)b.append(...u);else for(var n=0;n<g;n++)k.insertBefore(u[n]);n=D.$getSelection();if(D.$isRangeSelection(n)){k=n.anchor;u=k.getNode();n=n.focus;let F=k.getNode();
+u.is(e)?k.set(b.getKey(),k.offset,"element"):u.is(b)&&k.set(b.getKey(),g+k.offset,"element");F.is(e)?n.set(b.getKey(),n.offset,"element"):F.is(b)&&n.set(b.getKey(),g+n.offset,"element")}e.remove()}}},{tag:"history-merge"})}m=x}}))},[a,c,q,f])}
+function H(a,c,h){var f=Intl.Segmenter;let q=0;var l=0;if("function"===typeof f){a=(new f).segment(a);for(var {segment:m}of a){l+=h(m);if(l>c)break;q+=m.length}}else for(m=Array.from(a),a=m.length,f=0;f<a;f++){let d=m[f];l+=h(d);if(l>c)break;q+=d.length}return q}function J(a){let c=w.$createOverflowNode();a.insertBefore(c);c.append(a);return c}function I(a){let c=a.getChildren(),h=c.length;for(let f=0;f<h;f++)a.insertBefore(c[f]);a.remove();return 0<h?c[h-1]:null}let K=null;
+function M({remainingCharacters:a}){return v.createElement("span",{className:`characters-limit ${0>a?"characters-limit-exceeded":""}`},a)}
+exports.CharacterLimitPlugin=function({charset:a="UTF-16",maxLength:c=5,renderer:h=M}){let [f]=p.useLexicalComposerContext(),[q,l]=v.useState(c),m=v.useMemo(()=>({remainingCharacters:l,strlen:d=>{if("UTF-8"===a){if(void 0===window.TextEncoder)var r=null;else null===K&&(K=new window.TextEncoder),r=K;null===r?(r=encodeURIComponent(d).match(/%[89ABab]/g),d=d.length+(r?r.length:0)):d=r.encode(d).length;return d}if("UTF-16"===a)return d.length;throw Error("Unrecognized charset");}}),[a]);G(f,c,m);return h({remainingCharacters:q})}