zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/dist/LexicalCharacterLimitPlugin.dev.js

@@ -0,0 +1,292 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+'use strict';
+
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var react = require('react');
+var overflow = require('@lexical/overflow');
+var text = require('@lexical/text');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
+var jsxRuntime = require('react/jsx-runtime');
+
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({})) {
+  const {
+    strlen = input => input.length,
+    // UTF-16
+    remainingCharacters = () => {
+      return;
+    }
+  } = optional;
+  react.useEffect(() => {
+    if (!editor.hasNodes([overflow.OverflowNode])) {
+      {
+        formatDevErrorMessage(`useCharacterLimit: OverflowNode not registered on editor`);
+      }
+    }
+  }, [editor]);
+  react.useEffect(() => {
+    let text$1 = editor.getEditorState().read(text.$rootTextContent);
+    let lastComputedTextLength = 0;
+    return utils.mergeRegister(editor.registerTextContentListener(currentText => {
+      text$1 = 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$1);
+      const textLengthAboveThreshold = textLength > maxCharacters || lastComputedTextLength !== null && lastComputedTextLength > maxCharacters;
+      const diff = maxCharacters - textLength;
+      remainingCharacters(diff);
+      if (lastComputedTextLength === null || textLengthAboveThreshold) {
+        const offset = findOffset(text$1, maxCharacters, strlen);
+        editor.update(() => {
+          $wrapOverflowedNodes(offset);
+        }, {
+          tag: lexical.HISTORY_MERGE_TAG
+        });
+      }
+      lastComputedTextLength = textLength;
+    }), editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, isBackward => {
+      const selection = lexical.$getSelection();
+      if (!lexical.$isRangeSelection(selection)) {
+        return false;
+      }
+      const anchorNode = selection.anchor.getNode();
+      const overflow = anchorNode.getParent();
+      const overflowParent = overflow ? overflow.getParent() : null;
+      const parentNext = overflowParent ? overflowParent.getNextSibling() : null;
+      selection.deleteCharacter(isBackward);
+      if (overflowParent && overflowParent.isEmpty()) {
+        overflowParent.remove();
+      } else if (lexical.$isElementNode(parentNext) && parentNext.isEmpty()) {
+        parentNext.remove();
+      }
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW));
+  }, [editor, maxCharacters, remainingCharacters, strlen]);
+}
+function findOffset(text, maxCharacters, strlen) {
+  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 = utils.$dfs();
+  const dfsNodesLength = dfsNodes.length;
+  let accumulatedLength = 0;
+  for (let i = 0; i < dfsNodesLength; i += 1) {
+    const {
+      node
+    } = dfsNodes[i];
+    const needsOverflowParent = lexical.$isLeafNode(node) && !utils.$findMatchingParent(node, overflow.$isOverflowNode);
+    if (overflow.$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();
+        utils.$unwrapNode(node);
+        const selection = lexical.$getSelection();
+
+        // Restore selection when the overflow children are removed
+        if (lexical.$isRangeSelection(selection) && (!selection.anchor.getNode().isAttached() || !selection.focus.getNode().isAttached())) {
+          if (lexical.$isTextNode(previousSibling)) {
+            previousSibling.select();
+          } else if (lexical.$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 = lexical.$isTextNode(descendant) && descendant.isSimpleText();
+        const firstDescendantDoesNotOverflow = previousPlusDescendantLength <= offset;
+        if (firstDescendantIsSimpleText || firstDescendantDoesNotOverflow) {
+          utils.$unwrapNode(node);
+        }
+      }
+    } else if (needsOverflowParent) {
+      const previousAccumulatedLength = accumulatedLength;
+      accumulatedLength += node.getTextContentSize();
+      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
+        if (previousAccumulatedLength < offset && lexical.$isTextNode(node) && node.isSimpleText()) {
+          const [, overflowedText] = node.splitText(offset - previousAccumulatedLength);
+          overflowNode = $wrapNode(overflowedText);
+        } else {
+          overflowNode = $wrapNode(node);
+        }
+        if (previousSelection !== null) {
+          lexical.$setSelection(previousSelection);
+        }
+        $mergePrevious(overflowNode);
+      }
+    }
+  }
+}
+function $wrapNode(node) {
+  const overflowNode = overflow.$createOverflowNode();
+  node.replace(overflowNode);
+  overflowNode.append(node);
+  return overflowNode;
+}
+function $mergePrevious(overflowNode) {
+  const previousNode = overflowNode.getPreviousSibling();
+  if (!overflow.$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 = lexical.$getSelection();
+  if (lexical.$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__*/jsxRuntime.jsx("span", {
+    className: `characters-limit ${remainingCharacters < 0 ? 'characters-limit-exceeded' : ''}`,
+    children: remainingCharacters
+  });
+}
+function CharacterLimitPlugin({
+  charset = 'UTF-16',
+  maxLength = CHARACTER_LIMIT,
+  renderer = DefaultRenderer
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const [remainingCharacters, setRemainingCharacters] = react.useState(maxLength);
+  const characterLimitProps = react.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
+  });
+}
+
+exports.CharacterLimitPlugin = CharacterLimitPlugin;

package/dist/LexicalCharacterLimitPlugin.dev.mjs

@@ -0,0 +1,290 @@
+/**
+ * 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 { useEffect, useState, useMemo } from 'react';
+import { OverflowNode, $isOverflowNode, $createOverflowNode } from '@lexical/overflow';
+import { $rootTextContent } from '@lexical/text';
+import { mergeRegister, $dfs, $findMatchingParent, $unwrapNode } from '@lexical/utils';
+import { HISTORY_MERGE_TAG, DELETE_CHARACTER_COMMAND, $getSelection, $isRangeSelection, $isElementNode, COMMAND_PRIORITY_LOW, $isLeafNode, $isTextNode, $setSelection } from 'lexical';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+function useCharacterLimit(editor, maxCharacters, optional = Object.freeze({})) {
+  const {
+    strlen = input => input.length,
+    // UTF-16
+    remainingCharacters = () => {
+      return;
+    }
+  } = optional;
+  useEffect(() => {
+    if (!editor.hasNodes([OverflowNode])) {
+      {
+        formatDevErrorMessage(`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_TAG
+        });
+      }
+      lastComputedTextLength = textLength;
+    }), editor.registerCommand(DELETE_CHARACTER_COMMAND, isBackward => {
+      const selection = $getSelection();
+      if (!$isRangeSelection(selection)) {
+        return false;
+      }
+      const anchorNode = selection.anchor.getNode();
+      const overflow = anchorNode.getParent();
+      const overflowParent = overflow ? overflow.getParent() : null;
+      const parentNext = overflowParent ? overflowParent.getNextSibling() : null;
+      selection.deleteCharacter(isBackward);
+      if (overflowParent && overflowParent.isEmpty()) {
+        overflowParent.remove();
+      } else if ($isElementNode(parentNext) && parentNext.isEmpty()) {
+        parentNext.remove();
+      }
+      return true;
+    }, COMMAND_PRIORITY_LOW));
+  }, [editor, maxCharacters, remainingCharacters, strlen]);
+}
+function findOffset(text, maxCharacters, strlen) {
+  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];
+    const needsOverflowParent = $isLeafNode(node) && !$findMatchingParent(node, $isOverflowNode);
+    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 (needsOverflowParent) {
+      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.replace(overflowNode);
+  overflowNode.append(node);
+  return overflowNode;
+}
+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__*/jsx("span", {
+    className: `characters-limit ${remainingCharacters < 0 ? 'characters-limit-exceeded' : ''}`,
+    children: 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/dist/LexicalCharacterLimitPlugin.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.
+ *
+ */
+
+'use strict'
+const LexicalCharacterLimitPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalCharacterLimitPlugin.dev.js') : require('./LexicalCharacterLimitPlugin.prod.js');
+module.exports = LexicalCharacterLimitPlugin;

package/dist/LexicalCharacterLimitPlugin.mjs

@@ -0,0 +1,12 @@
+/**
+ * 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.mjs';
+import * as modProd from './LexicalCharacterLimitPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const CharacterLimitPlugin = mod.CharacterLimitPlugin;

package/dist/LexicalCharacterLimitPlugin.node.mjs

@@ -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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalCharacterLimitPlugin.dev.mjs') : import('./LexicalCharacterLimitPlugin.prod.mjs'));
+export const CharacterLimitPlugin = mod.CharacterLimitPlugin;

package/dist/LexicalCharacterLimitPlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+"use strict";var e=require("@lexical/react/LexicalComposerContext"),t=require("react"),n=require("@lexical/overflow"),r=require("@lexical/text"),i=require("@lexical/utils"),o=require("lexical"),s=require("react/jsx-runtime");function l(e,s,l=Object.freeze({})){const{strlen:f=e=>e.length,remainingCharacters:g=()=>{}}=l;t.useEffect(()=>{e.hasNodes([n.OverflowNode])||function(e,...t){const n=new URL("https://lexical.dev/docs/error"),r=new URLSearchParams;r.append("code",e);for(const e of t)r.append("v",e);throw n.search=r.toString(),Error(`Minified Lexical error #${e}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}(57)},[e]),t.useEffect(()=>{let t=e.getEditorState().read(r.$rootTextContent),l=0;return i.mergeRegister(e.registerTextContentListener(e=>{t=e}),e.registerUpdateListener(({dirtyLeaves:r,dirtyElements:u})=>{const d=e.isComposing(),h=r.size>0||u.size>0;if(d||!h)return;const m=f(t),x=m>s||null!==l&&l>s;if(g(s-m),null===l||x){const r=function(e,t,n){const r=Intl.Segmenter;let i=0,o=0;if("function"==typeof r){const s=(new r).segment(e);for(const{segment:e}of s){const r=o+n(e);if(r>t)break;o=r,i+=e.length}}else{const r=Array.from(e),s=r.length;for(let e=0;e<s;e++){const s=r[e],l=o+n(s);if(l>t)break;o=l,i+=s.length}}return i}(t,s,f);e.update(()=>{!function(e){const t=i.$dfs(),r=t.length;let s=0;for(let l=0;l<r;l+=1){const{node:r}=t[l],f=o.$isLeafNode(r)&&!i.$findMatchingParent(r,n.$isOverflowNode);if(n.$isOverflowNode(r)){const t=s;if(s+r.getTextContentSize()<=e){const e=r.getParent(),t=r.getPreviousSibling(),n=r.getNextSibling();i.$unwrapNode(r);const s=o.$getSelection();!o.$isRangeSelection(s)||s.anchor.getNode().isAttached()&&s.focus.getNode().isAttached()||(o.$isTextNode(t)?t.select():o.$isTextNode(n)?n.select():null!==e&&e.select())}else if(t<e){const n=r.getFirstDescendant(),s=t+(null!==n?n.getTextContentSize():0);(o.$isTextNode(n)&&n.isSimpleText()||s<=e)&&i.$unwrapNode(r)}}else if(f){const t=s;if(s+=r.getTextContentSize(),s>e&&!n.$isOverflowNode(r.getParent())){const n=o.$getSelection();let i;if(t<e&&o.$isTextNode(r)&&r.isSimpleText()){const[,n]=r.splitText(e-t);i=c(n)}else i=c(r);null!==n&&o.$setSelection(n),a(i)}}}}(r)},{tag:o.HISTORY_MERGE_TAG})}l=m}),e.registerCommand(o.DELETE_CHARACTER_COMMAND,e=>{const t=o.$getSelection();if(!o.$isRangeSelection(t))return!1;const n=t.anchor.getNode().getParent(),r=n?n.getParent():null,i=r?r.getNextSibling():null;return t.deleteCharacter(e),r&&r.isEmpty()?r.remove():o.$isElementNode(i)&&i.isEmpty()&&i.remove(),!0},o.COMMAND_PRIORITY_LOW))},[e,s,g,f])}function c(e){const t=n.$createOverflowNode();return e.replace(t),t.append(e),t}function a(e){const t=e.getPreviousSibling();if(!n.$isOverflowNode(t))return;const r=e.getFirstChild(),i=t.getChildren(),s=i.length;if(null===r)e.append(...i);else for(let e=0;e<s;e++)r.insertBefore(i[e]);const l=o.$getSelection();if(o.$isRangeSelection(l)){const n=l.anchor,r=n.getNode(),i=l.focus,o=n.getNode();r.is(t)?n.set(e.getKey(),n.offset,"element"):r.is(e)&&n.set(e.getKey(),s+n.offset,"element"),o.is(t)?i.set(e.getKey(),i.offset,"element"):o.is(e)&&i.set(e.getKey(),s+i.offset,"element")}t.remove()}let f=null;function g(e){const t=void 0===window.TextEncoder?null:(null===f&&(f=new window.TextEncoder),f);if(null===t){const t=encodeURIComponent(e).match(/%[89ABab]/g);return e.length+(t?t.length:0)}return t.encode(e).length}function u({remainingCharacters:e}){return s.jsx("span",{className:"characters-limit "+(e<0?"characters-limit-exceeded":""),children:e})}exports.CharacterLimitPlugin=function({charset:n="UTF-16",maxLength:r=5,renderer:i=u}){const[o]=e.useLexicalComposerContext(),[s,c]=t.useState(r),a=t.useMemo(()=>({remainingCharacters:c,strlen:e=>{if("UTF-8"===n)return g(e);if("UTF-16"===n)return e.length;throw new Error("Unrecognized charset")}}),[n]);return l(o,r,a),i({remainingCharacters:s})};

package/dist/LexicalCharacterLimitPlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import{useLexicalComposerContext as e}from"@lexical/react/LexicalComposerContext";import{useEffect as t,useState as n,useMemo as r}from"react";import{OverflowNode as o,$isOverflowNode as i,$createOverflowNode as s}from"@lexical/overflow";import{$rootTextContent as l}from"@lexical/text";import{mergeRegister as c,$dfs as a,$findMatchingParent as f,$unwrapNode as g}from"@lexical/utils";import{HISTORY_MERGE_TAG as m,DELETE_CHARACTER_COMMAND as u,$getSelection as d,$isRangeSelection as h,$isElementNode as p,COMMAND_PRIORITY_LOW as x,$isLeafNode as C,$isTextNode as S,$setSelection as v}from"lexical";import{jsx as w}from"react/jsx-runtime";function T(e,n,r=Object.freeze({})){const{strlen:s=e=>e.length,remainingCharacters:w=()=>{}}=r;t(()=>{e.hasNodes([o])||function(e,...t){const n=new URL("https://lexical.dev/docs/error"),r=new URLSearchParams;r.append("code",e);for(const e of t)r.append("v",e);throw n.search=r.toString(),Error(`Minified Lexical error #${e}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}(57)},[e]),t(()=>{let t=e.getEditorState().read(l),r=0;return c(e.registerTextContentListener(e=>{t=e}),e.registerUpdateListener(({dirtyLeaves:o,dirtyElements:l})=>{const c=e.isComposing(),u=o.size>0||l.size>0;if(c||!u)return;const p=s(t),x=p>n||null!==r&&r>n;if(w(n-p),null===r||x){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}(t,n,s);e.update(()=>{!function(e){const t=a(),n=t.length;let r=0;for(let o=0;o<n;o+=1){const{node:n}=t[o],s=C(n)&&!f(n,i);if(i(n)){const t=r;if(r+n.getTextContentSize()<=e){const e=n.getParent(),t=n.getPreviousSibling(),r=n.getNextSibling();g(n);const o=d();!h(o)||o.anchor.getNode().isAttached()&&o.focus.getNode().isAttached()||(S(t)?t.select():S(r)?r.select():null!==e&&e.select())}else if(t<e){const r=n.getFirstDescendant(),o=t+(null!==r?r.getTextContentSize():0);(S(r)&&r.isSimpleText()||o<=e)&&g(n)}}else if(s){const t=r;if(r+=n.getTextContentSize(),r>e&&!i(n.getParent())){const r=d();let o;if(t<e&&S(n)&&n.isSimpleText()){const[,r]=n.splitText(e-t);o=y(r)}else o=y(n);null!==r&&v(r),N(o)}}}}(r)},{tag:m})}r=p}),e.registerCommand(u,e=>{const t=d();if(!h(t))return!1;const n=t.anchor.getNode().getParent(),r=n?n.getParent():null,o=r?r.getNextSibling():null;return t.deleteCharacter(e),r&&r.isEmpty()?r.remove():p(o)&&o.isEmpty()&&o.remove(),!0},x))},[e,n,w,s])}function y(e){const t=s();return e.replace(t),t.append(e),t}function N(e){const t=e.getPreviousSibling();if(!i(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 s=d();if(h(s)){const n=s.anchor,r=n.getNode(),i=s.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)?i.set(e.getKey(),i.offset,"element"):l.is(e)&&i.set(e.getKey(),o+i.offset,"element")}t.remove()}let b=null;function E(e){const t=void 0===window.TextEncoder?null:(null===b&&(b=new window.TextEncoder),b);if(null===t){const t=encodeURIComponent(e).match(/%[89ABab]/g);return e.length+(t?t.length:0)}return t.encode(e).length}function L({remainingCharacters:e}){return w("span",{className:"characters-limit "+(e<0?"characters-limit-exceeded":""),children:e})}function U({charset:t="UTF-16",maxLength:o=5,renderer:i=L}){const[s]=e(),[l,c]=n(o);return T(s,o,r(()=>({remainingCharacters:c,strlen:e=>{if("UTF-8"===t)return E(e);if("UTF-16"===t)return e.length;throw new Error("Unrecognized charset")}}),[t])),i({remainingCharacters:l})}export{U as CharacterLimitPlugin};

package/dist/LexicalCheckListPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ *
+ */
+export declare function CheckListPlugin(): null;