@payloadcms/richtext-lexical 0.1.16 → 0.2.0

package/dist/field/features/Link/plugins/autoLink/index.js

@@ -32,7 +32,7 @@ function createLinkMatcherWithRegExp(regExp, urlTransformer = (text)=>text) {
             index: match.index,
             length: match[0].length,
             text: match[0],
-            url: urlTransformer(text)
+            url: urlTransformer(match[0])
         };
     };
 }
@@ -69,45 +69,139 @@ function isNextNodeValid(node) {
     }
     return nextNode === null || (0, _lexical.$isLineBreakNode)(nextNode) || (0, _lexical.$isTextNode)(nextNode) && startsWithSeparator(nextNode.getTextContent());
 }
-function isContentAroundIsValid(matchStart, matchEnd, text, node) {
-    const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node);
+function isContentAroundIsValid(matchStart, matchEnd, text, nodes) {
+    const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(nodes[0]);
     if (!contentBeforeIsValid) {
         return false;
     }
-    const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node);
+    const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(nodes[nodes.length - 1]);
     return contentAfterIsValid;
 }
-function handleLinkCreation(node, matchers, onChange) {
-    const nodeText = node.getTextContent();
-    let text = nodeText;
-    let invalidMatchEnd = 0;
-    let remainingTextNode = node;
+function extractMatchingNodes(nodes, startIndex, endIndex) {
+    const unmodifiedBeforeNodes = [];
+    const matchingNodes = [];
+    const unmodifiedAfterNodes = [];
+    let matchingOffset = 0;
+    let currentOffset = 0;
+    const currentNodes = [
+        ...nodes
+    ];
+    while(currentNodes.length > 0){
+        const currentNode = currentNodes[0];
+        const currentNodeText = currentNode.getTextContent();
+        const currentNodeLength = currentNodeText.length;
+        const currentNodeStart = currentOffset;
+        const currentNodeEnd = currentOffset + currentNodeLength;
+        if (currentNodeEnd <= startIndex) {
+            unmodifiedBeforeNodes.push(currentNode);
+            matchingOffset += currentNodeLength;
+        } else if (currentNodeStart >= endIndex) {
+            unmodifiedAfterNodes.push(currentNode);
+        } else {
+            matchingNodes.push(currentNode);
+        }
+        currentOffset += currentNodeLength;
+        currentNodes.shift();
+    }
+    return [
+        matchingOffset,
+        unmodifiedBeforeNodes,
+        matchingNodes,
+        unmodifiedAfterNodes
+    ];
+}
+function createAutoLinkNode(nodes, startIndex, endIndex, match) {
+    const fields = {
+        linkType: 'custom',
+        url: match.url,
+        ...match.fields
+    };
+    const linkNode = (0, _AutoLinkNode.$createAutoLinkNode)({
+        fields
+    });
+    if (nodes.length === 1) {
+        let remainingTextNode = nodes[0];
+        let linkTextNode;
+        if (startIndex === 0) {
+            [linkTextNode, remainingTextNode] = remainingTextNode.splitText(endIndex);
+        } else {
+            [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(startIndex, endIndex);
+        }
+        const textNode = (0, _lexical.$createTextNode)(match.text);
+        textNode.setFormat(linkTextNode.getFormat());
+        textNode.setDetail(linkTextNode.getDetail());
+        linkNode.append(textNode);
+        linkTextNode.replace(linkNode);
+        return remainingTextNode;
+    } else if (nodes.length > 1) {
+        const firstTextNode = nodes[0];
+        let offset = firstTextNode.getTextContent().length;
+        let firstLinkTextNode;
+        if (startIndex === 0) {
+            firstLinkTextNode = firstTextNode;
+        } else {
+            [, firstLinkTextNode] = firstTextNode.splitText(startIndex);
+        }
+        const linkNodes = [];
+        let remainingTextNode;
+        for(let i = 1; i < nodes.length; i++){
+            const currentNode = nodes[i];
+            const currentNodeText = currentNode.getTextContent();
+            const currentNodeLength = currentNodeText.length;
+            const currentNodeStart = offset;
+            const currentNodeEnd = offset + currentNodeLength;
+            if (currentNodeStart < endIndex) {
+                if (currentNodeEnd <= endIndex) {
+                    linkNodes.push(currentNode);
+                } else {
+                    const [linkTextNode, endNode] = currentNode.splitText(endIndex - currentNodeStart);
+                    linkNodes.push(linkTextNode);
+                    remainingTextNode = endNode;
+                }
+            }
+            offset += currentNodeLength;
+        }
+        const selection = (0, _lexical.$getSelection)();
+        const selectedTextNode = selection ? selection.getNodes().find(_lexical.$isTextNode) : undefined;
+        const textNode = (0, _lexical.$createTextNode)(firstLinkTextNode.getTextContent());
+        textNode.setFormat(firstLinkTextNode.getFormat());
+        textNode.setDetail(firstLinkTextNode.getDetail());
+        linkNode.append(textNode, ...linkNodes);
+        // it does not preserve caret position if caret was at the first text node
+        // so we need to restore caret position
+        if (selectedTextNode && selectedTextNode === firstLinkTextNode) {
+            if ((0, _lexical.$isRangeSelection)(selection)) {
+                textNode.select(selection.anchor.offset, selection.focus.offset);
+            } else if ((0, _lexical.$isNodeSelection)(selection)) {
+                textNode.select(0, textNode.getTextContent().length);
+            }
+        }
+        firstLinkTextNode.replace(linkNode);
+        return remainingTextNode;
+    }
+    return undefined;
+}
+function handleLinkCreation(nodes, matchers, onChange) {
+    let currentNodes = [
+        ...nodes
+    ];
+    let text = currentNodes.map((node)=>node.getTextContent()).join('');
     let match;
+    let invalidMatchEnd = 0;
     while((match = findFirstMatch(text, matchers)) != null && match !== null){
         const matchStart = match.index;
         const matchLength = match.length;
         const matchEnd = matchStart + matchLength;
-        const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, nodeText, node);
+        const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, text, currentNodes);
         if (isValid) {
-            let linkTextNode;
-            if (invalidMatchEnd + matchStart === 0) {
-                [linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchLength);
-            } else {
-                [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchStart, invalidMatchEnd + matchStart + matchLength);
-            }
-            const fields = {
-                linkType: 'custom',
-                url: match.url,
-                ...match.attributes
-            };
-            const linkNode = (0, _AutoLinkNode.$createAutoLinkNode)({
-                fields
-            });
-            const textNode = (0, _lexical.$createTextNode)(match.text);
-            textNode.setFormat(linkTextNode.getFormat());
-            textNode.setDetail(linkTextNode.getDetail());
-            linkNode.append(textNode);
-            linkTextNode.replace(linkNode);
+            const [matchingOffset, , matchingNodes, unmodifiedAfterNodes] = extractMatchingNodes(currentNodes, invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd);
+            const actualMatchStart = invalidMatchEnd + matchStart - matchingOffset;
+            const actualMatchEnd = invalidMatchEnd + matchEnd - matchingOffset;
+            const remainingTextNode = createAutoLinkNode(matchingNodes, actualMatchStart, actualMatchEnd, match);
+            currentNodes = remainingTextNode ? [
+                remainingTextNode,
+                ...unmodifiedAfterNodes
+            ] : unmodifiedAfterNodes;
             onChange(match.url, null);
             invalidMatchEnd = 0;
         } else {
@@ -150,7 +244,7 @@ function handleLinkEdit(linkNode, matchers, onChange) {
         onChange(match.url, url ?? null);
     }
 }
-// Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.
+// Bad neighbors are edits in neighbor nodes that make AutoLinks incompatible.
 // Given the creation preconditions, these can only be simple text nodes.
 function handleBadNeighbors(textNode, matchers, onChange) {
     const previousSibling = textNode.getPreviousSibling();
@@ -176,6 +270,21 @@ function replaceWithChildren(node) {
     node.remove();
     return children.map((child)=>child.getLatest());
 }
+function getTextNodesToMatch(textNode) {
+    // check if next siblings are simple text nodes till a node contains a space separator
+    const textNodesToMatch = [
+        textNode
+    ];
+    let nextSibling = textNode.getNextSibling();
+    while(nextSibling !== null && (0, _lexical.$isTextNode)(nextSibling) && nextSibling.isSimpleText()){
+        textNodesToMatch.push(nextSibling);
+        if (/\s/.test(nextSibling.getTextContent())) {
+            break;
+        }
+        nextSibling = nextSibling.getNextSibling();
+    }
+    return textNodesToMatch;
+}
 function useAutoLink(editor, matchers, onChange) {
     (0, _react.useEffect)(()=>{
         if (!editor.hasNodes([
@@ -195,7 +304,8 @@ function useAutoLink(editor, matchers, onChange) {
                 handleLinkEdit(parent, matchers, onChangeWrapped);
             } else if (!(0, _LinkNode.$isLinkNode)(parent)) {
                 if (textNode.isSimpleText() && (startsWithSeparator(textNode.getTextContent()) || !(0, _AutoLinkNode.$isAutoLinkNode)(previous))) {
-                    handleLinkCreation(textNode, matchers, onChangeWrapped);
+                    const textNodesToMatch = getTextNodesToMatch(textNode);
+                    handleLinkCreation(textNodesToMatch, matchers, onChangeWrapped);
                 }
                 handleBadNeighbors(textNode, matchers, onChangeWrapped);
             }
@@ -222,4 +332,4 @@ function AutoLinkPlugin() {
     return null;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/Link/plugins/autoLink/index.tsx"],"sourcesContent":["'use client'\nimport type { ElementNode, LexicalEditor, LexicalNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport { $createTextNode, $isElementNode, $isLineBreakNode, $isTextNode, TextNode } from 'lexical'\nimport { useEffect } from 'react'\n\nimport { invariant } from '../../../../lexical/utils/invariant'\nimport { $createAutoLinkNode, $isAutoLinkNode, AutoLinkNode } from '../../nodes/AutoLinkNode'\nimport { $isLinkNode, type LinkFields } from '../../nodes/LinkNode'\n\ntype ChangeHandler = (url: null | string, prevUrl: null | string) => void\n\ninterface LinkMatcherResult {\n  fields?: LinkFields\n  index: number\n  length: number\n  text: string\n  url: string\n}\n\nexport type LinkMatcher = (text: string) => LinkMatcherResult | null\n\nexport function createLinkMatcherWithRegExp(\n  regExp: RegExp,\n  urlTransformer: (text: string) => string = (text) => text,\n) {\n  return (text: string) => {\n    const match = regExp.exec(text)\n    if (match === null) return null\n    return {\n      index: match.index,\n      length: match[0].length,\n      text: match[0],\n      url: urlTransformer(text),\n    }\n  }\n}\n\nfunction findFirstMatch(text: string, matchers: LinkMatcher[]): LinkMatcherResult | null {\n  for (let i = 0; i < matchers.length; i++) {\n    const match = matchers[i](text)\n\n    if (match != null) {\n      return match\n    }\n  }\n\n  return null\n}\n\nconst PUNCTUATION_OR_SPACE = /[.,;\\s]/\n\nfunction isSeparator(char: string): boolean {\n  return PUNCTUATION_OR_SPACE.test(char)\n}\n\nfunction endsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[textContent.length - 1])\n}\n\nfunction startsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[0])\n}\n\nfunction isPreviousNodeValid(node: LexicalNode): boolean {\n  let previousNode = node.getPreviousSibling()\n  if ($isElementNode(previousNode)) {\n    previousNode = previousNode.getLastDescendant()\n  }\n  return (\n    previousNode === null ||\n    $isLineBreakNode(previousNode) ||\n    ($isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent()))\n  )\n}\n\nfunction isNextNodeValid(node: LexicalNode): boolean {\n  let nextNode = node.getNextSibling()\n  if ($isElementNode(nextNode)) {\n    nextNode = nextNode.getFirstDescendant()\n  }\n  return (\n    nextNode === null ||\n    $isLineBreakNode(nextNode) ||\n    ($isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent()))\n  )\n}\n\nfunction isContentAroundIsValid(\n  matchStart: number,\n  matchEnd: number,\n  text: string,\n  node: TextNode,\n): boolean {\n  const contentBeforeIsValid =\n    matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node)\n  if (!contentBeforeIsValid) {\n    return false\n  }\n\n  const contentAfterIsValid =\n    matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node)\n  return contentAfterIsValid\n}\n\nfunction handleLinkCreation(\n  node: TextNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  const nodeText = node.getTextContent()\n  let text = nodeText\n  let invalidMatchEnd = 0\n  let remainingTextNode = node\n  let match\n\n  while ((match = findFirstMatch(text, matchers)) != null && match !== null) {\n    const matchStart: number = match.index\n    const matchLength: number = match.length\n    const matchEnd = matchStart + matchLength\n    const isValid = isContentAroundIsValid(\n      invalidMatchEnd + matchStart,\n      invalidMatchEnd + matchEnd,\n      nodeText,\n      node,\n    )\n\n    if (isValid) {\n      let linkTextNode\n      if (invalidMatchEnd + matchStart === 0) {\n        ;[linkTextNode, remainingTextNode] = remainingTextNode.splitText(\n          invalidMatchEnd + matchLength,\n        )\n      } else {\n        ;[, linkTextNode, remainingTextNode] = remainingTextNode.splitText(\n          invalidMatchEnd + matchStart,\n          invalidMatchEnd + matchStart + matchLength,\n        )\n      }\n      const fields: LinkFields = {\n        linkType: 'custom',\n        url: match.url,\n        ...match.attributes,\n      }\n\n      const linkNode = $createAutoLinkNode({ fields })\n      const textNode = $createTextNode(match.text)\n      textNode.setFormat(linkTextNode.getFormat())\n      textNode.setDetail(linkTextNode.getDetail())\n      linkNode.append(textNode)\n      linkTextNode.replace(linkNode)\n      onChange(match.url, null)\n      invalidMatchEnd = 0\n    } else {\n      invalidMatchEnd += matchEnd\n    }\n\n    text = text.substring(matchEnd)\n  }\n}\n\nfunction handleLinkEdit(\n  linkNode: AutoLinkNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  // Check children are simple text\n  const children = linkNode.getChildren()\n  const childrenLength = children.length\n  for (let i = 0; i < childrenLength; i++) {\n    const child = children[i]\n    if (!$isTextNode(child) || !child.isSimpleText()) {\n      replaceWithChildren(linkNode)\n      onChange(null, linkNode.getFields()?.url ?? null)\n      return\n    }\n  }\n\n  // Check text content fully matches\n  const text = linkNode.getTextContent()\n  const match = findFirstMatch(text, matchers)\n  if (match === null || match.text !== text) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  // Check neighbors\n  if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  const url = linkNode.getFields()?.url\n  if (url !== match?.url) {\n    const flds = linkNode.getFields()\n    flds.url = match?.url\n    linkNode.setFields(flds)\n    onChange(match.url, url ?? null)\n  }\n}\n\n// Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.\n// Given the creation preconditions, these can only be simple text nodes.\nfunction handleBadNeighbors(\n  textNode: TextNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  const previousSibling = textNode.getPreviousSibling()\n  const nextSibling = textNode.getNextSibling()\n  const text = textNode.getTextContent()\n\n  if ($isAutoLinkNode(previousSibling) && !startsWithSeparator(text)) {\n    previousSibling.append(textNode)\n    handleLinkEdit(previousSibling, matchers, onChange)\n    onChange(null, previousSibling.getFields()?.url ?? null)\n  }\n\n  if ($isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {\n    replaceWithChildren(nextSibling)\n    handleLinkEdit(nextSibling, matchers, onChange)\n    onChange(null, nextSibling.getFields()?.url ?? null)\n  }\n}\n\nfunction replaceWithChildren(node: ElementNode): LexicalNode[] {\n  const children = node.getChildren()\n  const childrenLength = children.length\n\n  for (let j = childrenLength - 1; j >= 0; j--) {\n    node.insertAfter(children[j])\n  }\n\n  node.remove()\n  return children.map((child) => child.getLatest())\n}\n\nfunction useAutoLink(\n  editor: LexicalEditor,\n  matchers: LinkMatcher[],\n  onChange?: ChangeHandler,\n): void {\n  useEffect(() => {\n    if (!editor.hasNodes([AutoLinkNode])) {\n      invariant(false, 'LexicalAutoLinkPlugin: AutoLinkNode not registered on editor')\n    }\n\n    const onChangeWrapped = (url: null | string, prevUrl: null | string): void => {\n      if (onChange != null) {\n        onChange(url, prevUrl)\n      }\n    }\n\n    return mergeRegister(\n      editor.registerNodeTransform(TextNode, (textNode: TextNode) => {\n        const parent = textNode.getParentOrThrow()\n        const previous = textNode.getPreviousSibling()\n        if ($isAutoLinkNode(parent)) {\n          handleLinkEdit(parent, matchers, onChangeWrapped)\n        } else if (!$isLinkNode(parent)) {\n          if (\n            textNode.isSimpleText() &&\n            (startsWithSeparator(textNode.getTextContent()) || !$isAutoLinkNode(previous))\n          ) {\n            handleLinkCreation(textNode, matchers, onChangeWrapped)\n          }\n\n          handleBadNeighbors(textNode, matchers, onChangeWrapped)\n        }\n      }),\n    )\n  }, [editor, matchers, onChange])\n}\n\nconst URL_REGEX =\n  /((https?:\\/\\/(www\\.)?)|(www\\.))[-\\w@:%.+~#=]{1,256}\\.[a-zA-Z\\d()]{1,6}\\b([-\\w()@:%+.~#?&/=]*)/\n\nconst EMAIL_REGEX =\n  /(([^<>()[\\]\\\\.,;:\\s@\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\])|(([a-zA-Z\\-\\d]+\\.)+[a-zA-Z]{2,}))/\n\nconst MATCHERS = [\n  createLinkMatcherWithRegExp(URL_REGEX, (text) => {\n    return text.startsWith('http') ? text : `https://${text}`\n  }),\n  createLinkMatcherWithRegExp(EMAIL_REGEX, (text) => {\n    return `mailto:${text}`\n  }),\n]\n\nexport function AutoLinkPlugin(): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n\n  useAutoLink(editor, MATCHERS)\n\n  return null\n}\n"],"names":["createLinkMatcherWithRegExp","AutoLinkPlugin","regExp","urlTransformer","text","match","exec","index","length","url","findFirstMatch","matchers","i","PUNCTUATION_OR_SPACE","isSeparator","char","test","endsWithSeparator","textContent","startsWithSeparator","isPreviousNodeValid","node","previousNode","getPreviousSibling","$isElementNode","getLastDescendant","$isLineBreakNode","$isTextNode","getTextContent","isNextNodeValid","nextNode","getNextSibling","getFirstDescendant","isContentAroundIsValid","matchStart","matchEnd","contentBeforeIsValid","contentAfterIsValid","handleLinkCreation","onChange","nodeText","invalidMatchEnd","remainingTextNode","matchLength","isValid","linkTextNode","splitText","fields","linkType","attributes","linkNode","$createAutoLinkNode","textNode","$createTextNode","setFormat","getFormat","setDetail","getDetail","append","replace","substring","handleLinkEdit","children","getChildren","childrenLength","child","isSimpleText","replaceWithChildren","getFields","flds","setFields","handleBadNeighbors","previousSibling","nextSibling","$isAutoLinkNode","j","insertAfter","remove","map","getLatest","useAutoLink","editor","useEffect","hasNodes","AutoLinkNode","invariant","onChangeWrapped","prevUrl","mergeRegister","registerNodeTransform","TextNode","parent","getParentOrThrow","previous","$isLinkNode","URL_REGEX","EMAIL_REGEX","MATCHERS","startsWith","useLexicalComposerContext"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/Link/plugins/autoLink/index.tsx"],"sourcesContent":["'use client'\nimport type { ElementNode, LexicalEditor, LexicalNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $createTextNode,\n  $getSelection,\n  $isElementNode,\n  $isLineBreakNode,\n  $isNodeSelection,\n  $isRangeSelection,\n  $isTextNode,\n  TextNode,\n} from 'lexical'\nimport { useEffect } from 'react'\n\nimport { invariant } from '../../../../lexical/utils/invariant'\nimport { $createAutoLinkNode, $isAutoLinkNode, AutoLinkNode } from '../../nodes/AutoLinkNode'\nimport { $isLinkNode, type LinkFields } from '../../nodes/LinkNode'\n\ntype ChangeHandler = (url: null | string, prevUrl: null | string) => void\n\ninterface LinkMatcherResult {\n  fields?: LinkFields\n  index: number\n  length: number\n  text: string\n  url: string\n}\n\nexport type LinkMatcher = (text: string) => LinkMatcherResult | null\n\nexport function createLinkMatcherWithRegExp(\n  regExp: RegExp,\n  urlTransformer: (text: string) => string = (text) => text,\n) {\n  return (text: string) => {\n    const match = regExp.exec(text)\n    if (match === null) return null\n    return {\n      index: match.index,\n      length: match[0].length,\n      text: match[0],\n      url: urlTransformer(match[0]),\n    }\n  }\n}\n\nfunction findFirstMatch(text: string, matchers: LinkMatcher[]): LinkMatcherResult | null {\n  for (let i = 0; i < matchers.length; i++) {\n    const match = matchers[i](text)\n\n    if (match != null) {\n      return match\n    }\n  }\n\n  return null\n}\n\nconst PUNCTUATION_OR_SPACE = /[.,;\\s]/\n\nfunction isSeparator(char: string): boolean {\n  return PUNCTUATION_OR_SPACE.test(char)\n}\n\nfunction endsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[textContent.length - 1])\n}\n\nfunction startsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[0])\n}\n\nfunction isPreviousNodeValid(node: LexicalNode): boolean {\n  let previousNode = node.getPreviousSibling()\n  if ($isElementNode(previousNode)) {\n    previousNode = previousNode.getLastDescendant()\n  }\n  return (\n    previousNode === null ||\n    $isLineBreakNode(previousNode) ||\n    ($isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent()))\n  )\n}\n\nfunction isNextNodeValid(node: LexicalNode): boolean {\n  let nextNode = node.getNextSibling()\n  if ($isElementNode(nextNode)) {\n    nextNode = nextNode.getFirstDescendant()\n  }\n  return (\n    nextNode === null ||\n    $isLineBreakNode(nextNode) ||\n    ($isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent()))\n  )\n}\n\nfunction isContentAroundIsValid(\n  matchStart: number,\n  matchEnd: number,\n  text: string,\n  nodes: TextNode[],\n): boolean {\n  const contentBeforeIsValid =\n    matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(nodes[0])\n  if (!contentBeforeIsValid) {\n    return false\n  }\n\n  const contentAfterIsValid =\n    matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(nodes[nodes.length - 1])\n  return contentAfterIsValid\n}\n\nfunction extractMatchingNodes(\n  nodes: TextNode[],\n  startIndex: number,\n  endIndex: number,\n): [\n  matchingOffset: number,\n  unmodifiedBeforeNodes: TextNode[],\n  matchingNodes: TextNode[],\n  unmodifiedAfterNodes: TextNode[],\n] {\n  const unmodifiedBeforeNodes: TextNode[] = []\n  const matchingNodes: TextNode[] = []\n  const unmodifiedAfterNodes: TextNode[] = []\n  let matchingOffset = 0\n\n  let currentOffset = 0\n  const currentNodes = [...nodes]\n\n  while (currentNodes.length > 0) {\n    const currentNode = currentNodes[0]\n    const currentNodeText = currentNode.getTextContent()\n    const currentNodeLength = currentNodeText.length\n    const currentNodeStart = currentOffset\n    const currentNodeEnd = currentOffset + currentNodeLength\n\n    if (currentNodeEnd <= startIndex) {\n      unmodifiedBeforeNodes.push(currentNode)\n      matchingOffset += currentNodeLength\n    } else if (currentNodeStart >= endIndex) {\n      unmodifiedAfterNodes.push(currentNode)\n    } else {\n      matchingNodes.push(currentNode)\n    }\n    currentOffset += currentNodeLength\n    currentNodes.shift()\n  }\n  return [matchingOffset, unmodifiedBeforeNodes, matchingNodes, unmodifiedAfterNodes]\n}\n\nfunction createAutoLinkNode(\n  nodes: TextNode[],\n  startIndex: number,\n  endIndex: number,\n  match: LinkMatcherResult,\n): TextNode | undefined {\n  const fields: LinkFields = {\n    linkType: 'custom',\n    url: match.url,\n    ...match.fields,\n  }\n\n  const linkNode = $createAutoLinkNode({ fields })\n  if (nodes.length === 1) {\n    let remainingTextNode = nodes[0]\n    let linkTextNode\n    if (startIndex === 0) {\n      ;[linkTextNode, remainingTextNode] = remainingTextNode.splitText(endIndex)\n    } else {\n      ;[, linkTextNode, remainingTextNode] = remainingTextNode.splitText(startIndex, endIndex)\n    }\n    const textNode = $createTextNode(match.text)\n    textNode.setFormat(linkTextNode.getFormat())\n    textNode.setDetail(linkTextNode.getDetail())\n    linkNode.append(textNode)\n    linkTextNode.replace(linkNode)\n    return remainingTextNode\n  } else if (nodes.length > 1) {\n    const firstTextNode = nodes[0]\n    let offset = firstTextNode.getTextContent().length\n    let firstLinkTextNode\n    if (startIndex === 0) {\n      firstLinkTextNode = firstTextNode\n    } else {\n      ;[, firstLinkTextNode] = firstTextNode.splitText(startIndex)\n    }\n    const linkNodes = []\n    let remainingTextNode\n    for (let i = 1; i < nodes.length; i++) {\n      const currentNode = nodes[i]\n      const currentNodeText = currentNode.getTextContent()\n      const currentNodeLength = currentNodeText.length\n      const currentNodeStart = offset\n      const currentNodeEnd = offset + currentNodeLength\n      if (currentNodeStart < endIndex) {\n        if (currentNodeEnd <= endIndex) {\n          linkNodes.push(currentNode)\n        } else {\n          const [linkTextNode, endNode] = currentNode.splitText(endIndex - currentNodeStart)\n          linkNodes.push(linkTextNode)\n          remainingTextNode = endNode\n        }\n      }\n      offset += currentNodeLength\n    }\n    const selection = $getSelection()\n    const selectedTextNode = selection ? selection.getNodes().find($isTextNode) : undefined\n    const textNode = $createTextNode(firstLinkTextNode.getTextContent())\n    textNode.setFormat(firstLinkTextNode.getFormat())\n    textNode.setDetail(firstLinkTextNode.getDetail())\n    linkNode.append(textNode, ...linkNodes)\n    // it does not preserve caret position if caret was at the first text node\n    // so we need to restore caret position\n    if (selectedTextNode && selectedTextNode === firstLinkTextNode) {\n      if ($isRangeSelection(selection)) {\n        textNode.select(selection.anchor.offset, selection.focus.offset)\n      } else if ($isNodeSelection(selection)) {\n        textNode.select(0, textNode.getTextContent().length)\n      }\n    }\n    firstLinkTextNode.replace(linkNode)\n    return remainingTextNode\n  }\n  return undefined\n}\n\nfunction handleLinkCreation(\n  nodes: TextNode[],\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  let currentNodes = [...nodes]\n  let text = currentNodes.map((node) => node.getTextContent()).join('')\n\n  let match\n  let invalidMatchEnd = 0\n\n  while ((match = findFirstMatch(text, matchers)) != null && match !== null) {\n    const matchStart: number = match.index\n    const matchLength: number = match.length\n    const matchEnd = matchStart + matchLength\n    const isValid = isContentAroundIsValid(\n      invalidMatchEnd + matchStart,\n      invalidMatchEnd + matchEnd,\n      text,\n      currentNodes,\n    )\n\n    if (isValid) {\n      const [matchingOffset, , matchingNodes, unmodifiedAfterNodes] = extractMatchingNodes(\n        currentNodes,\n        invalidMatchEnd + matchStart,\n        invalidMatchEnd + matchEnd,\n      )\n\n      const actualMatchStart = invalidMatchEnd + matchStart - matchingOffset\n      const actualMatchEnd = invalidMatchEnd + matchEnd - matchingOffset\n      const remainingTextNode = createAutoLinkNode(\n        matchingNodes,\n        actualMatchStart,\n        actualMatchEnd,\n        match,\n      )\n      currentNodes = remainingTextNode\n        ? [remainingTextNode, ...unmodifiedAfterNodes]\n        : unmodifiedAfterNodes\n      onChange(match.url, null)\n      invalidMatchEnd = 0\n    } else {\n      invalidMatchEnd += matchEnd\n    }\n\n    text = text.substring(matchEnd)\n  }\n}\n\nfunction handleLinkEdit(\n  linkNode: AutoLinkNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  // Check children are simple text\n  const children = linkNode.getChildren()\n  const childrenLength = children.length\n  for (let i = 0; i < childrenLength; i++) {\n    const child = children[i]\n    if (!$isTextNode(child) || !child.isSimpleText()) {\n      replaceWithChildren(linkNode)\n      onChange(null, linkNode.getFields()?.url ?? null)\n      return\n    }\n  }\n\n  // Check text content fully matches\n  const text = linkNode.getTextContent()\n  const match = findFirstMatch(text, matchers)\n  if (match === null || match.text !== text) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  // Check neighbors\n  if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  const url = linkNode.getFields()?.url\n  if (url !== match?.url) {\n    const flds = linkNode.getFields()\n    flds.url = match?.url\n    linkNode.setFields(flds)\n    onChange(match.url, url ?? null)\n  }\n}\n\n// Bad neighbors are edits in neighbor nodes that make AutoLinks incompatible.\n// Given the creation preconditions, these can only be simple text nodes.\nfunction handleBadNeighbors(\n  textNode: TextNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  const previousSibling = textNode.getPreviousSibling()\n  const nextSibling = textNode.getNextSibling()\n  const text = textNode.getTextContent()\n\n  if ($isAutoLinkNode(previousSibling) && !startsWithSeparator(text)) {\n    previousSibling.append(textNode)\n    handleLinkEdit(previousSibling, matchers, onChange)\n    onChange(null, previousSibling.getFields()?.url ?? null)\n  }\n\n  if ($isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {\n    replaceWithChildren(nextSibling)\n    handleLinkEdit(nextSibling, matchers, onChange)\n    onChange(null, nextSibling.getFields()?.url ?? null)\n  }\n}\n\nfunction replaceWithChildren(node: ElementNode): LexicalNode[] {\n  const children = node.getChildren()\n  const childrenLength = children.length\n\n  for (let j = childrenLength - 1; j >= 0; j--) {\n    node.insertAfter(children[j])\n  }\n\n  node.remove()\n  return children.map((child) => child.getLatest())\n}\n\nfunction getTextNodesToMatch(textNode: TextNode): TextNode[] {\n  // check if next siblings are simple text nodes till a node contains a space separator\n  const textNodesToMatch = [textNode]\n  let nextSibling = textNode.getNextSibling()\n  while (nextSibling !== null && $isTextNode(nextSibling) && nextSibling.isSimpleText()) {\n    textNodesToMatch.push(nextSibling)\n    if (/\\s/.test(nextSibling.getTextContent())) {\n      break\n    }\n    nextSibling = nextSibling.getNextSibling()\n  }\n  return textNodesToMatch\n}\n\nfunction useAutoLink(\n  editor: LexicalEditor,\n  matchers: LinkMatcher[],\n  onChange?: ChangeHandler,\n): void {\n  useEffect(() => {\n    if (!editor.hasNodes([AutoLinkNode])) {\n      invariant(false, 'LexicalAutoLinkPlugin: AutoLinkNode not registered on editor')\n    }\n\n    const onChangeWrapped = (url: null | string, prevUrl: null | string): void => {\n      if (onChange != null) {\n        onChange(url, prevUrl)\n      }\n    }\n\n    return mergeRegister(\n      editor.registerNodeTransform(TextNode, (textNode: TextNode) => {\n        const parent = textNode.getParentOrThrow()\n        const previous = textNode.getPreviousSibling()\n        if ($isAutoLinkNode(parent)) {\n          handleLinkEdit(parent, matchers, onChangeWrapped)\n        } else if (!$isLinkNode(parent)) {\n          if (\n            textNode.isSimpleText() &&\n            (startsWithSeparator(textNode.getTextContent()) || !$isAutoLinkNode(previous))\n          ) {\n            const textNodesToMatch = getTextNodesToMatch(textNode)\n            handleLinkCreation(textNodesToMatch, matchers, onChangeWrapped)\n          }\n\n          handleBadNeighbors(textNode, matchers, onChangeWrapped)\n        }\n      }),\n    )\n  }, [editor, matchers, onChange])\n}\n\nconst URL_REGEX =\n  /((https?:\\/\\/(www\\.)?)|(www\\.))[-\\w@:%.+~#=]{1,256}\\.[a-zA-Z\\d()]{1,6}\\b([-\\w()@:%+.~#?&/=]*)/\n\nconst EMAIL_REGEX =\n  /(([^<>()[\\]\\\\.,;:\\s@\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\])|(([a-zA-Z\\-\\d]+\\.)+[a-zA-Z]{2,}))/\n\nconst MATCHERS = [\n  createLinkMatcherWithRegExp(URL_REGEX, (text) => {\n    return text.startsWith('http') ? text : `https://${text}`\n  }),\n  createLinkMatcherWithRegExp(EMAIL_REGEX, (text) => {\n    return `mailto:${text}`\n  }),\n]\n\nexport function AutoLinkPlugin(): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n\n  useAutoLink(editor, MATCHERS)\n\n  return null\n}\n"],"names":["createLinkMatcherWithRegExp","AutoLinkPlugin","regExp","urlTransformer","text","match","exec","index","length","url","findFirstMatch","matchers","i","PUNCTUATION_OR_SPACE","isSeparator","char","test","endsWithSeparator","textContent","startsWithSeparator","isPreviousNodeValid","node","previousNode","getPreviousSibling","$isElementNode","getLastDescendant","$isLineBreakNode","$isTextNode","getTextContent","isNextNodeValid","nextNode","getNextSibling","getFirstDescendant","isContentAroundIsValid","matchStart","matchEnd","nodes","contentBeforeIsValid","contentAfterIsValid","extractMatchingNodes","startIndex","endIndex","unmodifiedBeforeNodes","matchingNodes","unmodifiedAfterNodes","matchingOffset","currentOffset","currentNodes","currentNode","currentNodeText","currentNodeLength","currentNodeStart","currentNodeEnd","push","shift","createAutoLinkNode","fields","linkType","linkNode","$createAutoLinkNode","remainingTextNode","linkTextNode","splitText","textNode","$createTextNode","setFormat","getFormat","setDetail","getDetail","append","replace","firstTextNode","offset","firstLinkTextNode","linkNodes","endNode","selection","$getSelection","selectedTextNode","getNodes","find","undefined","$isRangeSelection","select","anchor","focus","$isNodeSelection","handleLinkCreation","onChange","map","join","invalidMatchEnd","matchLength","isValid","actualMatchStart","actualMatchEnd","substring","handleLinkEdit","children","getChildren","childrenLength","child","isSimpleText","replaceWithChildren","getFields","flds","setFields","handleBadNeighbors","previousSibling","nextSibling","$isAutoLinkNode","j","insertAfter","remove","getLatest","getTextNodesToMatch","textNodesToMatch","useAutoLink","editor","useEffect","hasNodes","AutoLinkNode","invariant","onChangeWrapped","prevUrl","mergeRegister","registerNodeTransform","TextNode","parent","getParentOrThrow","previous","$isLinkNode","URL_REGEX","EMAIL_REGEX","MATCHERS","startsWith","useLexicalComposerContext"],"mappings":"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"}

package/dist/field/features/Relationship/nodes/RelationshipNode.js

@@ -151,7 +151,7 @@ class RelationshipNode extends _LexicalDecoratorBlockNode.DecoratorBlockNode {
         return this.__id;
     }
     getTextContent() {
-        return `${this?.__data?.relationTo} relation to ${this.__data?.value?.id}`;
+        return `${this.__data?.relationTo} relation to ${this.__data?.value?.id}`;
     }
     setData(data) {
         const writable = this.getWritable();
@@ -167,4 +167,4 @@ function $isRelationshipNode(node) {
     return node instanceof RelationshipNode;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Relationship/nodes/RelationshipNode.tsx"],"sourcesContent":["import type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  EditorConfig,\n  ElementFormatType,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  Spread,\n} from 'lexical'\n\nimport {\n  DecoratorBlockNode,\n  type SerializedDecoratorBlockNode,\n} from '@lexical/react/LexicalDecoratorBlockNode'\nimport * as React from 'react'\n\nimport { RelationshipComponent } from './components/RelationshipComponent'\n\nexport type RelationshipData = {\n  relationTo: string\n  value: {\n    // Actual relationship, populated in afterRead hook\n    [key: string]: unknown\n    id: string\n  }\n}\n\nexport type SerializedRelationshipNode = Spread<RelationshipData, SerializedDecoratorBlockNode>\n\nfunction relationshipElementToNode(domNode: HTMLDivElement): DOMConversionOutput | null {\n  const id = domNode.getAttribute('data-lexical-relationship-id')\n  const relationTo = domNode.getAttribute('data-lexical-relationship-relationTo')\n\n  if (id != null && relationTo != null) {\n    const node = $createRelationshipNode({\n      relationTo,\n      value: {\n        id,\n      },\n    })\n    return { node }\n  }\n  return null\n}\n\nexport class RelationshipNode extends DecoratorBlockNode {\n  __data: RelationshipData\n\n  constructor({\n    data,\n    format,\n    key,\n  }: {\n    data: RelationshipData\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__data = data\n  }\n\n  static clone(node: RelationshipNode): RelationshipNode {\n    return new RelationshipNode({\n      data: node.__data,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'relationship'\n  }\n\n  static importDOM(): DOMConversionMap<HTMLDivElement> | null {\n    return {\n      div: (domNode: HTMLDivElement) => {\n        if (\n          !domNode.hasAttribute('data-lexical-relationship-relationTo') ||\n          !domNode.hasAttribute('data-lexical-relationship-id')\n        ) {\n          return null\n        }\n        return {\n          conversion: relationshipElementToNode,\n          priority: 2,\n        }\n      },\n    }\n  }\n\n  static importJSON(serializedNode: SerializedRelationshipNode): RelationshipNode {\n    const importedData: RelationshipData = {\n      relationTo: serializedNode.relationTo,\n      value: serializedNode.value,\n    }\n    const node = $createRelationshipNode(importedData)\n    node.setFormat(serializedNode.format)\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    return (\n      <RelationshipComponent\n        className={config.theme.relationship ?? 'LexicalEditorTheme__relationship'}\n        data={this.__data}\n        format={this.__format}\n        nodeKey={this.getKey()}\n      />\n    )\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('div')\n    element.setAttribute('data-lexical-relationship-id', this.__data?.value?.id)\n    element.setAttribute('data-lexical-relationship-relationTo', this.__data?.relationTo)\n\n    const text = document.createTextNode(this.getTextContent())\n    element.append(text)\n    return { element }\n  }\n\n  exportJSON(): SerializedRelationshipNode {\n    return {\n      ...super.exportJSON(),\n      ...this.getData(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  getData(): RelationshipData {\n    return this.getLatest().__data\n  }\n\n  getId(): string {\n    return this.__id\n  }\n\n  getTextContent(): string {\n    return `${this?.__data?.relationTo} relation to ${this.__data?.value?.id}`\n  }\n\n  setData(data: RelationshipData): void {\n    const writable = this.getWritable()\n    writable.__data = data\n  }\n}\n\nexport function $createRelationshipNode(data: RelationshipData): RelationshipNode {\n  return new RelationshipNode({\n    data,\n  })\n}\n\nexport function $isRelationshipNode(\n  node: LexicalNode | RelationshipNode | null | undefined,\n): node is RelationshipNode {\n  return node instanceof RelationshipNode\n}\n"],"names":["RelationshipNode","$createRelationshipNode","$isRelationshipNode","relationshipElementToNode","domNode","id","getAttribute","relationTo","node","value","DecoratorBlockNode","__data","constructor","data","format","key","clone","__format","__key","getType","importDOM","div","hasAttribute","conversion","priority","importJSON","serializedNode","importedData","setFormat","isInline","decorate","editor","config","RelationshipComponent","className","theme","relationship","nodeKey","getKey","exportDOM","element","document","createElement","setAttribute","text","createTextNode","getTextContent","append","exportJSON","getData","type","version","getLatest","getId","__id","setData","writable","getWritable"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Relationship/nodes/RelationshipNode.tsx"],"sourcesContent":["import type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  EditorConfig,\n  ElementFormatType,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  Spread,\n} from 'lexical'\n\nimport {\n  DecoratorBlockNode,\n  type SerializedDecoratorBlockNode,\n} from '@lexical/react/LexicalDecoratorBlockNode'\nimport * as React from 'react'\n\nimport { RelationshipComponent } from './components/RelationshipComponent'\n\nexport type RelationshipData = {\n  relationTo: string\n  value: {\n    // Actual relationship, populated in afterRead hook\n    [key: string]: unknown\n    id: string\n  }\n}\n\nexport type SerializedRelationshipNode = Spread<RelationshipData, SerializedDecoratorBlockNode>\n\nfunction relationshipElementToNode(domNode: HTMLDivElement): DOMConversionOutput | null {\n  const id = domNode.getAttribute('data-lexical-relationship-id')\n  const relationTo = domNode.getAttribute('data-lexical-relationship-relationTo')\n\n  if (id != null && relationTo != null) {\n    const node = $createRelationshipNode({\n      relationTo,\n      value: {\n        id,\n      },\n    })\n    return { node }\n  }\n  return null\n}\n\nexport class RelationshipNode extends DecoratorBlockNode {\n  __data: RelationshipData\n\n  constructor({\n    data,\n    format,\n    key,\n  }: {\n    data: RelationshipData\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__data = data\n  }\n\n  static clone(node: RelationshipNode): RelationshipNode {\n    return new RelationshipNode({\n      data: node.__data,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'relationship'\n  }\n\n  static importDOM(): DOMConversionMap<HTMLDivElement> | null {\n    return {\n      div: (domNode: HTMLDivElement) => {\n        if (\n          !domNode.hasAttribute('data-lexical-relationship-relationTo') ||\n          !domNode.hasAttribute('data-lexical-relationship-id')\n        ) {\n          return null\n        }\n        return {\n          conversion: relationshipElementToNode,\n          priority: 2,\n        }\n      },\n    }\n  }\n\n  static importJSON(serializedNode: SerializedRelationshipNode): RelationshipNode {\n    const importedData: RelationshipData = {\n      relationTo: serializedNode.relationTo,\n      value: serializedNode.value,\n    }\n    const node = $createRelationshipNode(importedData)\n    node.setFormat(serializedNode.format)\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    return (\n      <RelationshipComponent\n        className={config.theme.relationship ?? 'LexicalEditorTheme__relationship'}\n        data={this.__data}\n        format={this.__format}\n        nodeKey={this.getKey()}\n      />\n    )\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('div')\n    element.setAttribute('data-lexical-relationship-id', this.__data?.value?.id)\n    element.setAttribute('data-lexical-relationship-relationTo', this.__data?.relationTo)\n\n    const text = document.createTextNode(this.getTextContent())\n    element.append(text)\n    return { element }\n  }\n\n  exportJSON(): SerializedRelationshipNode {\n    return {\n      ...super.exportJSON(),\n      ...this.getData(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  getData(): RelationshipData {\n    return this.getLatest().__data\n  }\n\n  getId(): string {\n    return this.__id\n  }\n\n  getTextContent(): string {\n    return `${this.__data?.relationTo} relation to ${this.__data?.value?.id}`\n  }\n\n  setData(data: RelationshipData): void {\n    const writable = this.getWritable()\n    writable.__data = data\n  }\n}\n\nexport function $createRelationshipNode(data: RelationshipData): RelationshipNode {\n  return new RelationshipNode({\n    data,\n  })\n}\n\nexport function $isRelationshipNode(\n  node: LexicalNode | RelationshipNode | null | undefined,\n): node is RelationshipNode {\n  return node instanceof RelationshipNode\n}\n"],"names":["RelationshipNode","$createRelationshipNode","$isRelationshipNode","relationshipElementToNode","domNode","id","getAttribute","relationTo","node","value","DecoratorBlockNode","__data","constructor","data","format","key","clone","__format","__key","getType","importDOM","div","hasAttribute","conversion","priority","importJSON","serializedNode","importedData","setFormat","isInline","decorate","editor","config","RelationshipComponent","className","theme","relationship","nodeKey","getKey","exportDOM","element","document","createElement","setAttribute","text","createTextNode","getTextContent","append","exportJSON","getData","type","version","getLatest","getId","__id","setData","writable","getWritable"],"mappings":"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"}

package/dist/field/features/converters/html/field/index.d.ts

@@ -1,7 +1,23 @@
 import type { TextField } from 'payload/types';
+import type { SanitizedEditorConfig } from '../../../../../index';
+import type { HTMLConverter } from '../converter/types';
 type Props = {
     name: string;
 };
-export declare const lexicalHTML: (lexicalFieldName: string, props: Props) => TextField;
+/**
+ * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
+ *
+ * @param editorConfig
+ */
+export declare const consolidateHTMLConverters: ({ editorConfig, }: {
+    editorConfig: SanitizedEditorConfig;
+}) => HTMLConverter[];
+export declare const lexicalHTML: (
+/**
+ * A string which matches the lexical field name you want to convert to HTML.
+ *
+ * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.
+ **/
+lexicalFieldName: string, props: Props) => TextField;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/field/features/converters/html/field/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,eAAe,CAAA;AAW7D,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,gBAAgB,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,SAsErE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAwB,SAAS,EAAE,MAAM,eAAe,CAAA;AAEpE,OAAO,KAAK,EAA0B,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAEzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAMvD,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;kBAGtB,qBAAqB;qBAqBpC,CAAA;AAED,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,KAAK,KACT,SAuFJ,CAAA"}

package/dist/field/features/converters/html/field/index.js

@@ -2,15 +2,34 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "lexicalHTML", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    consolidateHTMLConverters: function() {
+        return consolidateHTMLConverters;
+    },
+    lexicalHTML: function() {
         return lexicalHTML;
     }
 });
-const _index = require("../../../../../index");
 const _converter = require("../converter");
 const _defaultConverters = require("../converter/defaultConverters");
+const consolidateHTMLConverters = ({ editorConfig })=>{
+    const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter');
+    const htmlConverterFeatureProps = htmlConverterFeature?.props;
+    const defaultConvertersWithConvertersFromFeatures = _defaultConverters.defaultHTMLConverters;
+    for (const converter of editorConfig.features.converters.html){
+        defaultConvertersWithConvertersFromFeatures.push(converter);
+    }
+    const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
+        defaultConverters: defaultConvertersWithConvertersFromFeatures
+    }) : (htmlConverterFeatureProps?.converters) || defaultConvertersWithConvertersFromFeatures;
+    return finalConverters;
+};
 const lexicalHTML = (lexicalFieldName, props)=>{
     const { name = 'lexicalHTML' } = props;
     return {
@@ -20,31 +39,51 @@ const lexicalHTML = (lexicalFieldName, props)=>{
         },
         hooks: {
             afterRead: [
-                async ({ collection, context, data, originalDoc, siblingData })=>{
-                    const lexicalField = collection.fields.find((field)=>'name' in field && field.name === lexicalFieldName);
+                async ({ collection, field, global, siblingData })=>{
+                    const fields = collection ? collection.fields : global.fields;
+                    // find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively
+                    function findFieldPathAndSiblingFields(fields, path) {
+                        for (const curField of fields){
+                            if (curField === field) {
+                                return {
+                                    path: [
+                                        ...path,
+                                        curField.name
+                                    ],
+                                    siblingFields: fields
+                                };
+                            }
+                            if ('fields' in curField && 'name' in curField) {
+                                const result = findFieldPathAndSiblingFields(curField.fields, [
+                                    ...path,
+                                    curField.name
+                                ]);
+                                if (result) {
+                                    return result;
+                                }
+                            }
+                        }
+                        return null;
+                    }
+                    const { path, siblingFields } = findFieldPathAndSiblingFields(fields, []);
+                    const lexicalField = siblingFields.find((field)=>'name' in field && field.name === lexicalFieldName);
                     const lexicalFieldData = siblingData[lexicalFieldName];
                     if (!lexicalFieldData) {
                         return '';
                     }
                     if (!lexicalField) {
-                        throw new Error('You cannot use the lexicalHTML field because the lexical field was not found');
+                        throw new Error('You cannot use the lexicalHTML field because the referenced lexical field was not found');
                     }
                     const config = (lexicalField?.editor)?.editorConfig;
                     if (!config) {
                         throw new Error('The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.');
                     }
                     if (!config?.resolvedFeatureMap?.has('htmlConverter')) {
-                        throw new Error('You cannot use the lexicalHTML field because the htmlConverter feature was not found');
+                        throw new Error('You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature');
                     }
-                    const htmlConverterFeature = config.resolvedFeatureMap.get('htmlConverter');
-                    const htmlConverterFeatureProps = htmlConverterFeature.props;
-                    const defaultConvertersWithConvertersFromFeatures = (0, _index.cloneDeep)(_defaultConverters.defaultHTMLConverters);
-                    for (const converter of config.features.converters.html){
-                        defaultConvertersWithConvertersFromFeatures.push(converter);
-                    }
-                    const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
-                        defaultConverters: defaultConvertersWithConvertersFromFeatures
-                    }) : (htmlConverterFeatureProps?.converters) || defaultConvertersWithConvertersFromFeatures;
+                    const finalConverters = consolidateHTMLConverters({
+                        editorConfig: config
+                    });
                     return await (0, _converter.convertLexicalToHTML)({
                         converters: finalConverters,
                         data: lexicalFieldData
@@ -56,4 +95,4 @@ const lexicalHTML = (lexicalFieldName, props)=>{
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/converters/html/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, RichTextField, TextField } from 'payload/types'\n\nimport type { LexicalRichTextAdapter, SanitizedEditorConfig } from '../../../../../index'\nimport type { AdapterProps } from '../../../../../types'\nimport type { HTMLConverter } from '../converter/types'\nimport type { HTMLConverterFeatureProps } from '../index'\n\nimport { convertLexicalToHTML } from '../converter'\nimport { defaultHTMLConverters } from '../converter/defaultConverters'\n\ntype Props = {\n  name: string\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedEditorConfig\n}) => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps = htmlConverterFeature?.props\n\n  const defaultConvertersWithConvertersFromFeatures = defaultHTMLConverters\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  return finalConverters\n}\n\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  props: Props,\n) => TextField = (lexicalFieldName, props) => {\n  const { name = 'lexicalHTML' } = props\n  return {\n    name: name,\n    admin: {\n      hidden: true,\n    },\n    hooks: {\n      afterRead: [\n        async ({ collection, field, global, siblingData }) => {\n          const fields = collection ? collection.fields : global.fields\n\n          // find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively\n          function findFieldPathAndSiblingFields(\n            fields: Field[],\n            path: string[],\n          ): {\n            path: string[]\n            siblingFields: Field[]\n          } {\n            for (const curField of fields) {\n              if (curField === field) {\n                return {\n                  path: [...path, curField.name],\n                  siblingFields: fields,\n                }\n              }\n\n              if ('fields' in curField && 'name' in curField) {\n                const result = findFieldPathAndSiblingFields(curField.fields, [\n                  ...path,\n                  curField.name,\n                ])\n                if (result) {\n                  return result\n                }\n              }\n            }\n\n            return null\n          }\n          const { path, siblingFields } = findFieldPathAndSiblingFields(fields, [])\n\n          const lexicalField: RichTextField<SerializedEditorState, AdapterProps> =\n            siblingFields.find(\n              (field) => 'name' in field && field.name === lexicalFieldName,\n            ) as RichTextField<SerializedEditorState, AdapterProps>\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            data: lexicalFieldData,\n          })\n        },\n      ],\n    },\n    type: 'text',\n  }\n}\n"],"names":["consolidateHTMLConverters","lexicalHTML","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","props","defaultConvertersWithConvertersFromFeatures","defaultHTMLConverters","converter","features","converters","html","push","finalConverters","defaultConverters","lexicalFieldName","name","admin","hidden","hooks","afterRead","collection","field","global","siblingData","fields","findFieldPathAndSiblingFields","path","curField","siblingFields","result","lexicalField","find","lexicalFieldData","Error","config","editor","has","convertLexicalToHTML","data","type"],"mappings":";;;;;;;;;;;IAoBaA,yBAAyB;eAAzBA;;IA0BAC,WAAW;eAAXA;;;2BAtCwB;mCACC;AAW/B,MAAMD,4BAA4B,CAAC,EACxCE,YAAY,EAGb;IACC,MAAMC,uBAAuBD,aAAaE,kBAAkB,CAACC,GAAG,CAAC;IACjE,MAAMC,4BAAuDH,sBAAsBI;IAEnF,MAAMC,8CAA8CC,wCAAqB;IAEzE,KAAK,MAAMC,aAAaR,aAAaS,QAAQ,CAACC,UAAU,CAACC,IAAI,CAAE;QAC7DL,4CAA4CM,IAAI,CAACJ;IACnD;IAEA,MAAMK,kBACJT,2BAA2BM,cAC3B,OAAON,2BAA2BM,eAAe,aAC7CN,0BAA0BM,UAAU,CAAC;QACnCI,mBAAmBR;IACrB,KACA,CAACF,2BAA2BM,UAA6B,KACzDJ;IAEN,OAAOO;AACT;AAEO,MAAMd,cAQI,CAACgB,kBAAkBV;IAClC,MAAM,EAAEW,OAAO,aAAa,EAAE,GAAGX;IACjC,OAAO;QACLW,MAAMA;QACNC,OAAO;YACLC,QAAQ;QACV;QACAC,OAAO;YACLC,WAAW;gBACT,OAAO,EAAEC,UAAU,EAAEC,KAAK,EAAEC,MAAM,EAAEC,WAAW,EAAE;oBAC/C,MAAMC,SAASJ,aAAaA,WAAWI,MAAM,GAAGF,OAAOE,MAAM;oBAE7D,kIAAkI;oBAClI,SAASC,8BACPD,MAAe,EACfE,IAAc;wBAKd,KAAK,MAAMC,YAAYH,OAAQ;4BAC7B,IAAIG,aAAaN,OAAO;gCACtB,OAAO;oCACLK,MAAM;2CAAIA;wCAAMC,SAASZ,IAAI;qCAAC;oCAC9Ba,eAAeJ;gCACjB;4BACF;4BAEA,IAAI,YAAYG,YAAY,UAAUA,UAAU;gCAC9C,MAAME,SAASJ,8BAA8BE,SAASH,MAAM,EAAE;uCACzDE;oCACHC,SAASZ,IAAI;iCACd;gCACD,IAAIc,QAAQ;oCACV,OAAOA;gCACT;4BACF;wBACF;wBAEA,OAAO;oBACT;oBACA,MAAM,EAAEH,IAAI,EAAEE,aAAa,EAAE,GAAGH,8BAA8BD,QAAQ,EAAE;oBAExE,MAAMM,eACJF,cAAcG,IAAI,CAChB,CAACV,QAAU,UAAUA,SAASA,MAAMN,IAAI,KAAKD;oBAGjD,MAAMkB,mBAA0CT,WAAW,CAACT,iBAAiB;oBAE7E,IAAI,CAACkB,kBAAkB;wBACrB,OAAO;oBACT;oBAEA,IAAI,CAACF,cAAc;wBACjB,MAAM,IAAIG,MACR;oBAEJ;oBAEA,MAAMC,SAAS,CAACJ,cAAcK,MAAgC,GAAGpC;oBAEjE,IAAI,CAACmC,QAAQ;wBACX,MAAM,IAAID,MACR;oBAEJ;oBAEA,IAAI,CAACC,QAAQjC,oBAAoBmC,IAAI,kBAAkB;wBACrD,MAAM,IAAIH,MACR;oBAEJ;oBAEA,MAAMrB,kBAAkBf,0BAA0B;wBAChDE,cAAcmC;oBAChB;oBAEA,OAAO,MAAMG,IAAAA,+BAAoB,EAAC;wBAChC5B,YAAYG;wBACZ0B,MAAMN;oBACR;gBACF;aACD;QACH;QACAO,MAAM;IACR;AACF"}

package/dist/field/features/debug/TestRecorder/index.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProvider } from '../../types';
+export declare const TestRecorderFeature: () => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/debug/TestRecorder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/debug/TestRecorder/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,eAAO,MAAM,mBAAmB,QAAO,eAetC,CAAA"}

package/dist/field/features/debug/TestRecorder/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TestRecorderFeature", {
+    enumerable: true,
+    get: function() {
+        return TestRecorderFeature;
+    }
+});
+const _plugin = require("./plugin");
+const TestRecorderFeature = ()=>{
+    return {
+        feature: ()=>{
+            return {
+                plugins: [
+                    {
+                        Component: _plugin.TestRecorderPlugin,
+                        position: 'bottom'
+                    }
+                ],
+                props: null
+            };
+        },
+        key: 'debug-testrecorder'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9kZWJ1Zy9UZXN0UmVjb3JkZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGZWF0dXJlUHJvdmlkZXIgfSBmcm9tICcuLi8uLi90eXBlcydcblxuaW1wb3J0IHsgVGVzdFJlY29yZGVyUGx1Z2luIH0gZnJvbSAnLi9wbHVnaW4nXG5cbmV4cG9ydCBjb25zdCBUZXN0UmVjb3JkZXJGZWF0dXJlID0gKCk6IEZlYXR1cmVQcm92aWRlciA9PiB7XG4gIHJldHVybiB7XG4gICAgZmVhdHVyZTogKCkgPT4ge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgcGx1Z2luczogW1xuICAgICAgICAgIHtcbiAgICAgICAgICAgIENvbXBvbmVudDogVGVzdFJlY29yZGVyUGx1Z2luLFxuICAgICAgICAgICAgcG9zaXRpb246ICdib3R0b20nLFxuICAgICAgICAgIH0sXG4gICAgICAgIF0sXG4gICAgICAgIHByb3BzOiBudWxsLFxuICAgICAgfVxuICAgIH0sXG4gICAga2V5OiAnZGVidWctdGVzdHJlY29yZGVyJyxcbiAgfVxufVxuIl0sIm5hbWVzIjpbIlRlc3RSZWNvcmRlckZlYXR1cmUiLCJmZWF0dXJlIiwicGx1Z2lucyIsIkNvbXBvbmVudCIsIlRlc3RSZWNvcmRlclBsdWdpbiIsInBvc2l0aW9uIiwicHJvcHMiLCJrZXkiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7Ozt3QkFGc0I7QUFFNUIsTUFBTUEsc0JBQXNCO0lBQ2pDLE9BQU87UUFDTEMsU0FBUztZQUNQLE9BQU87Z0JBQ0xDLFNBQVM7b0JBQ1A7d0JBQ0VDLFdBQVdDLDBCQUFrQjt3QkFDN0JDLFVBQVU7b0JBQ1o7aUJBQ0Q7Z0JBQ0RDLE9BQU87WUFDVDtRQUNGO1FBQ0FDLEtBQUs7SUFDUDtBQUNGIn0=

package/dist/field/features/debug/TestRecorder/plugin/index.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import './index.scss';
+export declare function isSelectAll(event: KeyboardEvent): boolean;
+export declare const TestRecorderPlugin: React.FC;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/debug/TestRecorder/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/debug/TestRecorder/plugin/index.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,cAAc,CAAA;AA8ErB,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEzD;AA+VD,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAYtC,CAAA"}