@lexical/react 0.1.4 → 0.1.8

package/DEPRECATED_useLexicalAutoFormatter.dev.js

@@ -0,0 +1,642 @@
+/**
+ * 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 list = require('@lexical/list');
+var lexical = require('lexical');
+var CodeNode = require('lexical/CodeNode');
+var react = require('react');
+var HeadingNode = require('lexical/HeadingNode');
+var QuoteNode = require('lexical/QuoteNode');
+
+/**
+ * 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.
+ *
+ * 
+ */
+// Caution, this function creates a string and should not be used within a tight loop.
+// Use $getNodeWithOffsetsFromJoinedTextNodesFromElementNode below to convert
+// indexes in the return string back into their corresponding node and offsets.
+
+function $joinTextNodesInElementNode(elementNode, separator, stopAt) {
+  let textContent = '';
+  const children = elementNode.getChildren();
+  const length = children.length;
+
+  for (let i = 0; i < length; ++i) {
+    const child = children[i];
+
+    if (lexical.$isTextNode(child)) {
+      const childTextContent = child.getTextContent();
+
+      if (child.is(stopAt.node)) {
+        if (stopAt.offset > childTextContent.length) {
+          {
+            throw Error(`Node ${child.__key} and selection point do not match.`);
+          }
+        }
+
+        textContent += child.getTextContent().substr(0, stopAt.offset);
+        break;
+      } else {
+        textContent += childTextContent;
+      }
+    } else {
+      textContent += separator;
+    }
+  }
+
+  return textContent;
+} // This function converts the offsetInJoinedText to
+// a node and offset result or null if not found.
+// This function is to be used in conjunction with joinTextNodesInElementNode above.
+// The joinedTextContent should be return value from joinTextNodesInElementNode.
+//
+// The offsetInJoinedText is relative to the entire string which
+// itself is relevant to the parent ElementNode.
+//
+// Example:
+// Given a Paragraph with 2 TextNodes. The first is Hello, the second is World.
+// The joinedTextContent would be "HelloWorld"
+// The offsetInJoinedText might be for the letter "e" = 1 or "r" = 7.
+// The return values would be {TextNode1, 1} or {TextNode2,2}, respectively.
+
+function $findNodeWithOffsetFromJoinedText(elementNode, joinedTextLength, offsetInJoinedText, separatorLength) {
+  const children = elementNode.getChildren();
+  const childrenLength = children.length;
+  let runningLength = 0;
+
+  for (let i = 0; i < childrenLength; ++i) {
+    if (runningLength >= joinedTextLength) {
+      break;
+    }
+
+    const child = children[i];
+    const childContentLength = lexical.$isTextNode(child) ? child.getTextContent().length : separatorLength;
+    const newRunningLength = runningLength + childContentLength;
+
+    if (runningLength <= offsetInJoinedText && offsetInJoinedText < newRunningLength && lexical.$isTextNode(child)) {
+      return {
+        node: child,
+        offset: offsetInJoinedText - runningLength
+      };
+    }
+
+    runningLength = newRunningLength;
+  }
+
+  return null;
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+// from the prior and current EditorState.
+// This is then used to determined if an auto format has been triggered.
+
+const TRIGGER_STRING = '\u0020'; // The space key triggers markdown.
+
+const TRIGGER_STRING_LENGTH = TRIGGER_STRING.length;
+const SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES = '\u0004'; // Select an unused unicode character to separate text and non-text nodes.
+
+const autoFormatBase = {
+  nodeTransformationKind: null,
+  regEx: /(?:)/,
+  regExCaptureGroupsToDelete: null,
+  regExExpectedCaptureGroupCount: 1,
+  requiresParagraphStart: false
+};
+const paragraphStartBase = { ...autoFormatBase,
+  requiresParagraphStart: true
+};
+const markdownHeader1 = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphH1',
+  regEx: /(?:# )/
+};
+const markdownHeader2 = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphH2',
+  regEx: /(?:## )/
+};
+const markdownHeader3 = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphH2',
+  regEx: /(?:### )/
+};
+const markdownBlockQuote = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphBlockQuote',
+  regEx: /(?:> )/
+};
+const markdownUnorderedListDash = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphUnorderedList',
+  regEx: /(?:- )/
+};
+const markdownUnorderedListAsterisk = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphUnorderedList',
+  regEx: /(?:\* )/
+};
+const markdownCodeBlock = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphCodeBlock',
+  regEx: /(?:``` )/
+};
+const markdownOrderedList = { ...paragraphStartBase,
+  nodeTransformationKind: 'paragraphOrderedList',
+  regEx: /^(\d+)\.\s/,
+  regExExpectedCaptureGroupCount: 2
+  /*e.g. '321. ' returns '321. ' & '321'*/
+
+};
+const markdownBold = { ...autoFormatBase,
+  nodeTransformationKind: 'textBold',
+  // regEx: /(\*)(?:\s*\b)(?:[^\*]*)(?:\b\s*)(\*\s)$/, // The $ will find the target at the end of the string.
+  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*\s)$/,
+  // Remove the first and last capture groups. Remeber, the 0th capture group is the entire string.
+  // e.g. "*Hello* " requires removing both "*" as well as bolding "Hello".
+  regExCaptureGroupsToDelete: [1, 5],
+  // The $ will find the target at the end of the string.
+  regExExpectedCaptureGroupCount: 6
+};
+const allAutoFormatCriteriaForTextNodes = [markdownBold];
+const allAutoFormatCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, ...allAutoFormatCriteriaForTextNodes];
+function getAllAutoFormatCriteriaForTextNodes() {
+  return allAutoFormatCriteriaForTextNodes;
+}
+function getAllAutoFormatCriteria() {
+  return allAutoFormatCriteria;
+}
+
+function getMatchResultContextWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx, regExExpectedCaptureGroupCount, scanningContext) {
+  const matchResultContext = {
+    regExCaptureGroups: [],
+    triggerState: null
+  };
+  const regExMatches = textToSearch.match(regEx);
+
+  if (regExMatches !== null && regExMatches.length > 0 && regExMatches.length === regExExpectedCaptureGroupCount && (matchMustAppearAtStartOfString === false || regExMatches.index === 0) && (matchMustAppearAtEndOfString === false || regExMatches.index + regExMatches[0].length === textToSearch.length)) {
+    const captureGroupsCount = regExMatches.length;
+    let runningLength = regExMatches.index;
+
+    for (let captureGroupIndex = 0; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
+      const textContent = regExMatches[captureGroupIndex];
+      matchResultContext.regExCaptureGroups.push({
+        anchorTextNodeWithOffset: null,
+        focusTextNodeWithOffset: null,
+        offsetInParent: runningLength,
+        text: textContent,
+        textLength: textContent.length - (captureGroupIndex + 1 === captureGroupsCount ? TRIGGER_STRING_LENGTH : 0)
+      }); // The 0th capture group is special in that it's text contents is
+      // a join of all subsequent capture groups. So, skip this group
+      // when calculating the runningLength.
+
+      if (captureGroupIndex > 0) {
+        runningLength += textContent.length;
+      }
+    }
+
+    return matchResultContext;
+  }
+
+  return null;
+}
+
+function getMatchResultContextForParagraphs(autoFormatCriteria, scanningContext) {
+  const textNodeWithOffset = scanningContext.textNodeWithOffset; // At start of paragraph.
+
+  if (textNodeWithOffset.node.getPreviousSibling() === null) {
+    const textToSearch = scanningContext.textNodeWithOffset.node.getTextContent();
+    return getMatchResultContextWithRegEx(textToSearch, true, false, autoFormatCriteria.regEx, autoFormatCriteria.regExExpectedCaptureGroupCount);
+  }
+
+  return null;
+}
+
+function getMatchResultContextForText(autoFormatCriteria, scanningContext) {
+  if (scanningContext.joinedText == null) {
+    const parentNode = scanningContext.textNodeWithOffset.node.getParentOrThrow();
+
+    if (lexical.$isElementNode(parentNode)) {
+      if (scanningContext.joinedText == null) {
+        // Lazy calculate the text to search.
+        scanningContext.joinedText = $joinTextNodesInElementNode(parentNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, scanningContext.textNodeWithOffset);
+      }
+
+      return getMatchResultContextWithRegEx(scanningContext.joinedText, false, true, autoFormatCriteria.regEx, autoFormatCriteria.regExExpectedCaptureGroupCount);
+    } else {
+      {
+        throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
+      }
+    }
+  } // This is a placeholder function for following PR's related to character based transformations.
+
+
+  return null;
+}
+
+function getMatchResultContextForCriteria(autoFormatCriteria, scanningContext) {
+  if (autoFormatCriteria.requiresParagraphStart !== null && autoFormatCriteria.requiresParagraphStart === true) {
+    return getMatchResultContextForParagraphs(autoFormatCriteria, scanningContext);
+  }
+
+  return getMatchResultContextForText(autoFormatCriteria, scanningContext);
+}
+
+function getNewNodeForCriteria(autoFormatCriteria, matchResultContext, children) {
+  let newNode = null;
+
+  if (autoFormatCriteria.nodeTransformationKind != null) {
+    switch (autoFormatCriteria.nodeTransformationKind) {
+      case 'paragraphH1':
+        {
+          newNode = HeadingNode.$createHeadingNode('h1');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphH2':
+        {
+          newNode = HeadingNode.$createHeadingNode('h2');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphH3':
+        {
+          newNode = HeadingNode.$createHeadingNode('h3');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphBlockQuote':
+        {
+          newNode = QuoteNode.$createQuoteNode();
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphUnorderedList':
+        {
+          newNode = list.$createListNode('ul');
+          const listItem = list.$createListItemNode();
+          listItem.append(...children);
+          newNode.append(listItem);
+          return newNode;
+        }
+
+      case 'paragraphOrderedList':
+        {
+          const startAsString = matchResultContext.regExCaptureGroups.length > 1 ? matchResultContext.regExCaptureGroups[matchResultContext.regExCaptureGroups.length - 1].text : '1';
+          const start = parseInt(startAsString, 10);
+          newNode = list.$createListNode('ol', start);
+          const listItem = list.$createListItemNode();
+          listItem.append(...children);
+          newNode.append(listItem);
+          return newNode;
+        }
+
+      case 'paragraphCodeBlock':
+        {
+          // Toggle code and paragraph nodes.
+          if (matchResultContext.triggerState != null && matchResultContext.triggerState.isCodeBlock) {
+            newNode = lexical.$createParagraphNode();
+          } else {
+            newNode = CodeNode.$createCodeNode();
+          }
+
+          newNode.append(...children);
+          return newNode;
+        }
+    }
+  }
+
+  return newNode;
+}
+
+function updateTextNode(node, count) {
+  const textNode = node.spliceText(0, count, '', true);
+
+  if (textNode.getTextContent() === '') {
+    textNode.selectPrevious();
+    textNode.remove();
+  }
+}
+
+function transformTextNodeForAutoFormatCriteria(scanningContext, autoFormatCriteria, matchResultContext) {
+  if (autoFormatCriteria.requiresParagraphStart) {
+    transformTextNodeForParagraphs(scanningContext, autoFormatCriteria, matchResultContext);
+  } else {
+    transformTextNodeForText(scanningContext, autoFormatCriteria, matchResultContext);
+  }
+}
+
+function transformTextNodeForParagraphs(scanningContext, autoFormatCriteria, matchResultContext) {
+  const textNodeWithOffset = scanningContext.textNodeWithOffset;
+  const element = textNodeWithOffset.node.getParentOrThrow();
+  const text = matchResultContext.regExCaptureGroups[0].text;
+  updateTextNode(textNodeWithOffset.node, text.length);
+  const elementNode = getNewNodeForCriteria(autoFormatCriteria, matchResultContext, element.getChildren());
+
+  if (elementNode !== null) {
+    element.replace(elementNode);
+  }
+}
+
+function transformTextNodeForText(scanningContext, autoFormatCriteria, matchResultContext) {
+  if (autoFormatCriteria.nodeTransformationKind != null) {
+    switch (autoFormatCriteria.nodeTransformationKind) {
+      case 'textBold':
+        {
+          matchResultContext.regExCaptureGroups = getCaptureGroupsByResolvingAllDetails(scanningContext, autoFormatCriteria, matchResultContext);
+
+          if (autoFormatCriteria.regExCaptureGroupsToDelete != null) {
+            // Remove unwanted text in reg ex patterh.
+            removeTextInCaptureGroups(autoFormatCriteria.regExCaptureGroupsToDelete, matchResultContext);
+            formatTextInCaptureGroupIndex('bold', 3, matchResultContext);
+          }
+
+          break;
+        }
+    }
+  }
+} // Some Capture Group Details were left lazily unresolved as their calculation
+// was not necessary during the scanning phase. Now that the nodeTransformationKind is
+// known, the details may be fully resolved without incurring unwasted performance cost.
+
+
+function getCaptureGroupsByResolvingAllDetails(scanningContext, autoFormatCriteria, matchResultContext) {
+  const textNodeWithOffset = scanningContext.textNodeWithOffset;
+  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
+  const captureGroupsCount = regExCaptureGroups.length;
+  const parentElementNode = textNodeWithOffset.node.getParentOrThrow();
+
+  if (scanningContext.joinedText == null) {
+    {
+      throw Error(`joinedText was not calculated`);
+    }
+  }
+
+  const joinedTextLength = scanningContext.joinedText.length;
+
+  for (let captureGroupIndex = 1; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
+    const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+    captureGroupDetail.anchorTextNodeWithOffset = $findNodeWithOffsetFromJoinedText(parentElementNode, joinedTextLength, captureGroupDetail.offsetInParent, TRIGGER_STRING_LENGTH);
+    captureGroupDetail.focusTextNodeWithOffset = $findNodeWithOffsetFromJoinedText(parentElementNode, joinedTextLength, captureGroupDetail.offsetInParent + captureGroupDetail.textLength, TRIGGER_STRING_LENGTH);
+
+    if (captureGroupDetail.textLength < 0) {
+      {
+        throw Error(`Bad regEx pattern found for ${autoFormatCriteria.nodeTransformationKind}`);
+      }
+    }
+  }
+
+  return regExCaptureGroups;
+}
+
+function removeTextInCaptureGroups(regExCaptureGroupsToDelete, matchResultContext) {
+  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  for (let i = regExCaptureGroupsToDelete.length - 1; i >= 0; i--) {
+    if (i < regExCaptureGroupsCount) {
+      const captureGroupIndex = regExCaptureGroupsToDelete[i];
+      const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+      const anchorTextNodeWithOffset = captureGroupDetail.anchorTextNodeWithOffset;
+      const focusTextNodeWithOffset = captureGroupDetail.focusTextNodeWithOffset;
+
+      if (anchorTextNodeWithOffset != null && focusTextNodeWithOffset != null && captureGroupDetail.textLength > 0) {
+        const newSelection = lexical.$createRangeSelection();
+        newSelection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
+        newSelection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
+        lexical.$setSelection(newSelection);
+        const currentSelection = lexical.$getSelection();
+
+        if (currentSelection != null) {
+          currentSelection.removeText(); // Shift offsets for capture groups which are within the same node
+
+          if (anchorTextNodeWithOffset.node.getKey() === focusTextNodeWithOffset.node.getKey()) {
+            const delta = focusTextNodeWithOffset.offset - anchorTextNodeWithOffset.offset;
+
+            if (!(delta > 0)) {
+              throw Error(`Expected anchor and focus offsets to have ascending character order.`);
+            }
+
+            shiftCaptureGroupOffsets(-delta, focusTextNodeWithOffset.offset, anchorTextNodeWithOffset.node, captureGroupIndex, matchResultContext);
+          } else {
+            const focusDelta = focusTextNodeWithOffset.offset;
+
+            if (focusDelta > 0) {
+              shiftCaptureGroupOffsets(-focusDelta, focusDelta, focusTextNodeWithOffset.node, captureGroupIndex, matchResultContext);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+function shiftCaptureGroupOffsets(delta, applyAtOrAfterOffset, node, startingCaptureGroupIndex, matchResultContext) {
+  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  for (let captureGroupIndex = startingCaptureGroupIndex + 1; captureGroupIndex < regExCaptureGroupsCount; captureGroupIndex++) {
+    const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+
+    if (captureGroupDetail.anchorTextNodeWithOffset != null && captureGroupDetail.anchorTextNodeWithOffset.offset >= applyAtOrAfterOffset && captureGroupDetail.anchorTextNodeWithOffset.node.is(node)) {
+      captureGroupDetail.anchorTextNodeWithOffset.offset += delta;
+    }
+
+    if (captureGroupDetail.focusTextNodeWithOffset != null && captureGroupDetail.focusTextNodeWithOffset.offset >= applyAtOrAfterOffset && captureGroupDetail.focusTextNodeWithOffset.node.is(node)) {
+      captureGroupDetail.focusTextNodeWithOffset.offset += delta;
+    }
+  }
+}
+
+function formatTextInCaptureGroupIndex(formatType, captureGroupIndex, matchResultContext) {
+  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  if (!(captureGroupIndex < regExCaptureGroupsCount)) {
+    throw Error(`The capture group count in the RegEx does match the actual capture group count.`);
+  }
+
+  const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+  const anchorTextNodeWithOffset = captureGroupDetail.anchorTextNodeWithOffset;
+  const focusTextNodeWithOffset = captureGroupDetail.focusTextNodeWithOffset;
+
+  if (anchorTextNodeWithOffset != null && focusTextNodeWithOffset != null && captureGroupDetail.textLength > 0) {
+    const newSelection = lexical.$createRangeSelection();
+    newSelection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
+    newSelection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
+    lexical.$setSelection(newSelection);
+    const currentSelection = lexical.$getSelection();
+
+    if (currentSelection != null) {
+      currentSelection.formatText(formatType);
+    }
+  }
+}
+
+/**
+ * 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 getCriteriaWithMatchResultContext(autoFormatCriteriaArray, currentTriggerState, scanningContext) {
+  const count = autoFormatCriteriaArray.length;
+
+  for (let i = 0; i < count; i++) {
+    const autoFormatCriteria = autoFormatCriteriaArray[i]; // Skip code block nodes, unless the nodeTransformationKind calls for toggling the code block.
+
+    if (currentTriggerState.isCodeBlock === false || autoFormatCriteria.nodeTransformationKind === 'paragraphCodeBlock') {
+      const matchResultContext = getMatchResultContextForCriteria(autoFormatCriteria, scanningContext);
+
+      if (matchResultContext != null) {
+        matchResultContext.triggerState = currentTriggerState;
+        return {
+          autoFormatCriteria: autoFormatCriteria,
+          matchResultContext
+        };
+      }
+    }
+  }
+
+  return {
+    autoFormatCriteria: null,
+    matchResultContext: null
+  };
+}
+
+function getTextNodeForAutoFormatting(selection) {
+  if (selection == null) {
+    return null;
+  }
+
+  const node = selection.anchor.getNode();
+
+  if (!lexical.$isTextNode(node)) {
+    return null;
+  }
+
+  return {
+    node,
+    offset: selection.anchor.offset
+  };
+}
+
+function updateAutoFormatting(editor, currentTriggerState) {
+  editor.update(() => {
+    const textNodeWithOffset = getTextNodeForAutoFormatting(lexical.$getSelection());
+
+    if (textNodeWithOffset === null) {
+      return;
+    } // Please see the declaration of ScanningContext for a detailed explanation.
+
+
+    const scanningContext = {
+      joinedText: null,
+      textNodeWithOffset
+    };
+    const criteriaWithMatchResultContext = getCriteriaWithMatchResultContext( // Do not apply paragraph node changes like blockQuote or H1 to listNodes. Also, do not attempt to transform a list into a list using * or -.
+    currentTriggerState.isParentAListItemNode === false ? getAllAutoFormatCriteria() : getAllAutoFormatCriteriaForTextNodes(), currentTriggerState, scanningContext);
+
+    if (criteriaWithMatchResultContext.autoFormatCriteria === null || criteriaWithMatchResultContext.matchResultContext === null) {
+      return;
+    }
+
+    transformTextNodeForAutoFormatCriteria(scanningContext, criteriaWithMatchResultContext.autoFormatCriteria, criteriaWithMatchResultContext.matchResultContext);
+  });
+}
+
+function shouldAttemptToAutoFormat(currentTriggerState, priorTriggerState) {
+  if (currentTriggerState == null || priorTriggerState == null) {
+    return false;
+  } // The below checks needs to execute relativey quickly, so perform the light-weight ones first.
+  // The substr check is a quick way to avoid autoformat parsing in that it looks for the autoformat
+  // trigger which is the trigger string (" ").
+
+
+  const triggerStringLength = TRIGGER_STRING.length;
+  const currentTextContentLength = currentTriggerState.textContent.length;
+  const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength;
+  return currentTriggerState.hasParentNode === true && currentTriggerState.isSimpleText && currentTriggerState.isSelectionCollapsed && currentTriggerState.nodeKey === priorTriggerState.nodeKey && currentTriggerState.anchorOffset !== priorTriggerState.anchorOffset && triggerOffset >= 0 && triggerOffset + triggerStringLength <= currentTextContentLength && currentTriggerState.textContent.substr(triggerOffset, triggerStringLength) === TRIGGER_STRING && currentTriggerState.textContent !== priorTriggerState.textContent;
+}
+
+function getTriggerState(editorState) {
+  let criteria = null;
+  editorState.read(() => {
+    const selection = lexical.$getSelection();
+
+    if (selection == null || !selection.isCollapsed()) {
+      return;
+    }
+
+    const node = selection.anchor.getNode();
+    const parentNode = node.getParent();
+    const isParentAListItemNode = parentNode !== null && list.$isListItemNode(parentNode);
+    const hasParentNode = parentNode !== null;
+    criteria = {
+      anchorOffset: selection.anchor.offset,
+      hasParentNode,
+      isCodeBlock: CodeNode.$isCodeNode(node),
+      isParentAListItemNode,
+      isSelectionCollapsed: selection.isCollapsed(),
+      isSimpleText: lexical.$isTextNode(node) && node.isSimpleText(),
+      nodeKey: node.getKey(),
+      textContent: node.getTextContent()
+    };
+  });
+  return criteria;
+}
+
+function useAutoFormatter(editor) {
+  react.useEffect(() => {
+    // The priorTriggerState is compared against the currentTriggerState to determine
+    // if the user has performed some typing event that warrants an auto format.
+    // For example, typing "#" and then " ", shoud trigger an format.
+    // However, given "#A B", where the user delets "A" should not.
+    let priorTriggerState = null;
+    editor.addListener('update', ({
+      tags
+    }) => {
+      // Examine historic so that we are not running autoformatting within markdown.
+      if (tags.has('historic') === false) {
+        const currentTriggerState = getTriggerState(editor.getEditorState());
+
+        if (shouldAttemptToAutoFormat(currentTriggerState, priorTriggerState) && currentTriggerState != null) {
+          updateAutoFormatting(editor, currentTriggerState);
+        }
+
+        priorTriggerState = currentTriggerState;
+      } else {
+        priorTriggerState = null;
+      }
+    });
+  }, [editor]);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function useLexicalAutoFormatter(editor) {
+  useAutoFormatter(editor);
+}
+
+module.exports = useLexicalAutoFormatter;

package/DEPRECATED_useLexicalAutoFormatter.js

@@ -1,12 +1,9 @@
-'use strict';var l=require("lexical/CodeNode"),m=require("lexical/ListItemNode"),t=require("lexical"),u=require("react"),w=require("lexical/HeadingNode"),x=require("lexical/ListNode"),y=require("lexical/ParagraphNode"),z=require("lexical/QuoteNode");
-const A={requiresParagraphStart:!1,nodeTransformationKind:null,regEx:/(?:)/,regExExpectedCaptureGroupCount:0},D={...A,requiresParagraphStart:!0},E=[{...A,nodeTransformationKind:"textBold",regEx:/(\*)(?:\s*\b)(?:[^\*]*)(?:\b\s*)(\*\s)$/,regExExpectedCaptureGroupCount:2}],F=[{...D,regEx:/(?:# )/,nodeTransformationKind:"paragraphH1"},{...D,regEx:/(?:## )/,nodeTransformationKind:"paragraphH2"},{...D,regEx:/(?:### )/,nodeTransformationKind:"paragraphH2"},{...D,regEx:/(?:> )/,nodeTransformationKind:"paragraphBlockQuote"},
-{...D,regEx:/(?:- )/,nodeTransformationKind:"paragraphUnorderedList"},{...D,regEx:/(?:\* )/,nodeTransformationKind:"paragraphUnorderedList"},{...D,nodeTransformationKind:"paragraphOrderedList",regEx:/^(\d+)\.\s/,regExExpectedCaptureGroupCount:1},{...D,regEx:/(?:``` )/,nodeTransformationKind:"paragraphCodeBlock"},...E];
-function G(f,h,b){const a={regExCaptureGroups:[],text:"",textIndex:-1,triggerState:null};f=f.match(h);if(null!==f&&0===f.index&&f.length===b+1){a.textIndex=f.index;a.text=f[0];for(b=1;b<f.length;++b)a.regExCaptureGroups.push(f[b]);return a}return null}
-function H(f,h){f.update(()=>{var b=t.$getSelection();if(null==b)b=null;else{var a=b.anchor.getNode();b=t.$isTextNode(a)?{node:a,offset:b.anchor.offset}:null}if(null!==b){b={textNodeWithOffset:b,trimmedParagraphText:null};a:{a=!1===h.isParentAListItemNode?F:E;var c=a.length;for(var e=0;e<c;++e){var d=a[e];if(!1===h.isCodeBlock||"paragraphCodeBlock"===d.nodeTransformationKind){var g=d,k=b;if(null!==g.requiresParagraphStart&&!0===g.requiresParagraphStart)b:{var n=k;k=n.textNodeWithOffset;if(null===
-k.node.getPreviousSibling()&&(n=n.textNodeWithOffset.node.getTextContent(),g=G(n,g.regEx,g.regExExpectedCaptureGroupCount),null!=g&&0===g.textIndex&&g.textIndex+g.text.length===k.offset))break b;g=null}else{if(null==k.trimmedParagraphText){var p=k.textNodeWithOffset.node.getParentOrThrow();if(t.$isElementNode(p)){if(null==k.trimmedParagraphText){n=k;var I=k.textNodeWithOffset.node,B=k.textNodeWithOffset.offset;let r="";p=p.getChildren();const J=p.length;for(let v=0;v<J;++v){const q=p[v];if(t.$isTextNode(q)){const C=
-q.getTextContent();if(q.is(I)){if(B>C.length)throw Error(`Node ${q.__key} and selection point do not match.`);r+=q.getTextContent().substr(0,B);break}else r+=C}else r+="\u0004"}n.trimmedParagraphText=r}G(k.trimmedParagraphText,g.regEx,g.regExExpectedCaptureGroupCount)}else throw Error(`Expected node ${p.__key} to to be a ElementNode.`);}g=null}if(null!=g){g.triggerState=h;a={autoFormatCriteria:d,matchResultContext:g};break a}}}a={autoFormatCriteria:null,matchResultContext:null}}c=a;if(null!==c.autoFormatCriteria&&
-null!==c.matchResultContext&&(a=c.autoFormatCriteria,c=c.matchResultContext,a.requiresParagraphStart)){e=b.textNodeWithOffset;b=e.node.getParentOrThrow();e=e.node.spliceText(0,c.text.length,"",!0);""===e.getTextContent()&&(e.selectPrevious(),e.remove());e=b.getChildren();d=null;if(null!=a.nodeTransformationKind)switch(a.nodeTransformationKind){case "paragraphH1":d=w.$createHeadingNode("h1");d.append(...e);break;case "paragraphH2":d=w.$createHeadingNode("h2");d.append(...e);break;case "paragraphH3":d=
-w.$createHeadingNode("h3");d.append(...e);break;case "paragraphBlockQuote":d=z.$createQuoteNode();d.append(...e);break;case "paragraphUnorderedList":d=x.$createListNode("ul");a=m.$createListItemNode();a.append(...e);d.append(a);break;case "paragraphOrderedList":a=parseInt(1===c.regExCaptureGroups.length?c.regExCaptureGroups[0]:"1",10);d=x.$createListNode("ol",a);a=m.$createListItemNode();a.append(...e);d.append(a);break;case "paragraphCodeBlock":d=null!=c.triggerState&&c.triggerState.isCodeBlock?
-y.$createParagraphNode():l.$createCodeNode(),d.append(...e)}a=d;null!==a&&b.replace(a)}}})}
-function K(f){let h=null;f.read(()=>{const b=t.$getSelection();if(null!=b&&b.isCollapsed()){var a=b.anchor.getNode(),c=a.getParent(),e=null!==c&&m.$isListItemNode(c);c=null!==c&&t.$isElementNode(c);h={anchorOffset:b.anchor.offset,isCodeBlock:l.$isCodeNode(a),isSelectionCollapsed:b.isCollapsed(),isSimpleText:t.$isTextNode(a)&&a.isSimpleText(),isParentAnElementNode:c,isParentAListItemNode:e,nodeKey:a.getKey(),textContent:a.getTextContent()}}});return h}
-function L(f){u.useEffect(()=>{let h=null;f.addListener("update",({tags:b})=>{if(!1===b.has("historic")){b=K(f.getEditorState());var a=b;var c=h;if(null==a||null==c)a=!1;else{var e=a.textContent.length,d=a.anchorOffset-1;a=!0===a.isParentAnElementNode&&a.isSimpleText&&a.isSelectionCollapsed&&a.nodeKey===c.nodeKey&&a.anchorOffset!==c.anchorOffset&&0<=d&&d+1<=e&&" "===a.textContent.substr(d,1)&&a.textContent!==c.textContent}a&&null!=b&&H(f,b);h=b}else h=null})},[f])}module.exports=function(f){L(f)};
+/**
+ * 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 DEPRECATED_useLexicalAutoFormatter = process.env.NODE_ENV === 'development' ? require('./DEPRECATED_useLexicalAutoFormatter.dev.js') : require('./DEPRECATED_useLexicalAutoFormatter.prod.js')
+module.exports = DEPRECATED_useLexicalAutoFormatter;