@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/features/Link/nodes/LinkNode.js

@@ -0,0 +1,368 @@
+/** @module @lexical/link */ /**
+ * 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";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LinkNode: function() {
+        return LinkNode;
+    },
+    $createLinkNode: function() {
+        return $createLinkNode;
+    },
+    $isLinkNode: function() {
+        return $isLinkNode;
+    },
+    TOGGLE_LINK_COMMAND: function() {
+        return TOGGLE_LINK_COMMAND;
+    },
+    toggleLink: function() {
+        return toggleLink;
+    }
+});
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const SUPPORTED_URL_PROTOCOLS = new Set([
+    'http:',
+    'https:',
+    'mailto:',
+    'sms:',
+    'tel:'
+]);
+class LinkNode extends _lexical.ElementNode {
+    __fields;
+    constructor({ fields = {
+        doc: null,
+        linkType: 'custom',
+        newTab: false,
+        url: undefined
+    }, key }){
+        super(key);
+        this.__fields = fields;
+    }
+    static clone(node) {
+        return new LinkNode({
+            fields: node.__fields,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'link';
+    }
+    static importDOM() {
+        return {
+            a: (node)=>({
+                    conversion: convertAnchorElement,
+                    priority: 1
+                })
+        };
+    }
+    static importJSON(serializedNode) {
+        const node = $createLinkNode({
+            fields: serializedNode.fields
+        });
+        node.setFormat(serializedNode.format);
+        node.setIndent(serializedNode.indent);
+        node.setDirection(serializedNode.direction);
+        return node;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    canInsertTextAfter() {
+        return false;
+    }
+    canInsertTextBefore() {
+        return false;
+    }
+    createDOM(config) {
+        const element = document.createElement('a');
+        if (this.__fields?.linkType === 'custom') {
+            element.href = this.sanitizeUrl(this.__fields.url ?? '');
+        }
+        if (this.__fields?.newTab ?? false) {
+            element.target = '_blank';
+        }
+        element.rel = '';
+        if (this.__fields?.newTab === true && this.__fields?.linkType === 'custom') {
+            element.rel = manageRel(element.rel, 'add', 'noopener');
+        }
+        if (this.__fields?.sponsored ?? false) {
+            element.rel = manageRel(element.rel, 'add', 'sponsored');
+        }
+        if (this.__fields?.nofollow ?? false) {
+            element.rel = manageRel(element.rel, 'add', 'nofollow');
+        }
+        if (this.__fields?.rel !== null) {
+            element.rel += ` ${this.__rel}`;
+        }
+        (0, _utils.addClassNamesToElement)(element, config.theme.link);
+        return element;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            fields: this.getFields(),
+            type: this.getType(),
+            version: 1
+        };
+    }
+    extractWithChild(child, selection, destination) {
+        if (!(0, _lexical.$isRangeSelection)(selection)) {
+            return false;
+        }
+        const anchorNode = selection.anchor.getNode();
+        const focusNode = selection.focus.getNode();
+        return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && selection.getTextContent().length > 0;
+    }
+    getFields() {
+        return this.getLatest().__fields;
+    }
+    insertNewAfter(selection, restoreSelection = true) {
+        const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
+        if ((0, _lexical.$isElementNode)(element)) {
+            const linkNode = $createLinkNode({
+                fields: this.__fields
+            });
+            element.append(linkNode);
+            return linkNode;
+        }
+        return null;
+    }
+    isInline() {
+        return true;
+    }
+    sanitizeUrl(url) {
+        try {
+            const parsedUrl = new URL(url);
+            // eslint-disable-next-line no-script-url
+            if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {
+                return 'about:blank';
+            }
+        } catch (e) {
+            return 'https://';
+        }
+        return url;
+    }
+    setFields(fields) {
+        const writable = this.getWritable();
+        writable.__fields = fields;
+    }
+    updateDOM(prevNode, anchor, config) {
+        const url = this.__fields?.url;
+        const newTab = this.__fields?.newTab;
+        const sponsored = this.__fields?.sponsored;
+        const nofollow = this.__fields?.nofollow;
+        const rel = this.__fields?.rel;
+        if (url != null && url !== prevNode.__fields?.url && this.__fields?.linkType === 'custom') {
+            anchor.href = url;
+        }
+        if (this.__fields?.linkType === 'internal' && prevNode.__fields?.linkType === 'custom') {
+            anchor.removeAttribute('href');
+        }
+        // TODO: not 100% sure why we're settign rel to '' - revisit
+        // Start rel config here, then check newTab below
+        if (anchor.rel == null) {
+            anchor.rel = '';
+        }
+        if (newTab !== prevNode.__fields?.newTab) {
+            if (newTab ?? false) {
+                anchor.target = '_blank';
+                if (this.__fields?.linkType === 'custom') {
+                    anchor.rel = manageRel(anchor.rel, 'add', 'noopener');
+                }
+            } else {
+                anchor.removeAttribute('target');
+                anchor.rel = manageRel(anchor.rel, 'remove', 'noopener');
+            }
+        }
+        if (nofollow !== prevNode.__fields.nofollow) {
+            if (nofollow ?? false) {
+                anchor.rel = manageRel(anchor.rel, 'add', 'nofollow');
+            } else {
+                anchor.rel = manageRel(anchor.rel, 'remove', 'nofollow');
+            }
+        }
+        if (sponsored !== prevNode.__fields.sponsored) {
+            if (sponsored ?? false) {
+                anchor.rel = manageRel(anchor.rel, 'add', 'sponsored');
+            } else {
+                anchor.rel = manageRel(anchor.rel, 'remove', 'sponsored');
+            }
+        }
+        // TODO - revisit - I don't think there can be any other rel
+        // values other than nofollow and noopener - so not
+        // sure why anchor.rel += rel below
+        if (rel !== prevNode.__fields.rel) {
+            if (rel != null) {
+                anchor.rel += rel;
+            } else {
+                anchor.removeAttribute('rel');
+            }
+        }
+        return false;
+    }
+}
+function convertAnchorElement(domNode) {
+    let node = null;
+    if ((0, _utils.isHTMLAnchorElement)(domNode)) {
+        const content = domNode.textContent;
+        if (content !== null && content !== '') {
+            node = $createLinkNode({
+                fields: {
+                    doc: null,
+                    linkType: 'custom',
+                    newTab: domNode.getAttribute('target') === '_blank',
+                    nofollow: domNode.getAttribute('rel')?.includes('nofollow') ?? false,
+                    rel: domNode.getAttribute('rel'),
+                    sponsored: domNode.getAttribute('rel')?.includes('sponsored') ?? false,
+                    url: domNode.getAttribute('href') ?? ''
+                }
+            });
+        }
+    }
+    return {
+        node
+    };
+}
+function $createLinkNode({ fields }) {
+    return (0, _lexical.$applyNodeReplacement)(new LinkNode({
+        fields
+    }));
+}
+function $isLinkNode(node) {
+    return node instanceof LinkNode;
+}
+const TOGGLE_LINK_COMMAND = (0, _lexical.createCommand)('TOGGLE_LINK_COMMAND');
+function toggleLink(payload) {
+    const selection = (0, _lexical.$getSelection)();
+    if (!(0, _lexical.$isRangeSelection)(selection)) {
+        return;
+    }
+    const nodes = selection.extract();
+    if (payload === null) {
+        // Remove LinkNodes
+        nodes.forEach((node)=>{
+            const parent = node.getParent();
+            if ($isLinkNode(parent)) {
+                const children = parent.getChildren();
+                for(let i = 0; i < children.length; i += 1){
+                    parent.insertBefore(children[i]);
+                }
+                parent.remove();
+            }
+        });
+    } else {
+        // Add or merge LinkNodes
+        if (nodes.length === 1) {
+            const firstNode = nodes[0];
+            // if the first node is a LinkNode or if its
+            // parent is a LinkNode, we update the URL, target and rel.
+            const linkNode = $isLinkNode(firstNode) ? firstNode : $getLinkAncestor(firstNode);
+            if (linkNode !== null) {
+                linkNode.setFields(payload.fields);
+                if (payload.text != null && payload.text !== linkNode.getTextContent()) {
+                    // remove all children and add child with new textcontent:
+                    linkNode.append((0, _lexical.$createTextNode)(payload.text));
+                    linkNode.getChildren().forEach((child)=>{
+                        if (child !== linkNode.getLastChild()) {
+                            child.remove();
+                        }
+                    });
+                }
+                return;
+            }
+        }
+        let prevParent = null;
+        let linkNode = null;
+        nodes.forEach((node)=>{
+            const parent = node.getParent();
+            if (parent === linkNode || parent === null || (0, _lexical.$isElementNode)(node) && !node.isInline()) {
+                return;
+            }
+            if ($isLinkNode(parent)) {
+                linkNode = parent;
+                parent.setFields(payload.fields);
+                if (payload.text != null && payload.text !== parent.getTextContent()) {
+                    // remove all children and add child with new textcontent:
+                    parent.append((0, _lexical.$createTextNode)(payload.text));
+                    parent.getChildren().forEach((child)=>{
+                        if (child !== parent.getLastChild()) {
+                            child.remove();
+                        }
+                    });
+                }
+                return;
+            }
+            if (!parent.is(prevParent)) {
+                prevParent = parent;
+                linkNode = $createLinkNode({
+                    fields: payload.fields
+                });
+                if ($isLinkNode(parent)) {
+                    if (node.getPreviousSibling() === null) {
+                        parent.insertBefore(linkNode);
+                    } else {
+                        parent.insertAfter(linkNode);
+                    }
+                } else {
+                    node.insertBefore(linkNode);
+                }
+            }
+            if ($isLinkNode(node)) {
+                if (node.is(linkNode)) {
+                    return;
+                }
+                if (linkNode !== null) {
+                    const children = node.getChildren();
+                    for(let i = 0; i < children.length; i += 1){
+                        linkNode.append(children[i]);
+                    }
+                }
+                node.remove();
+                return;
+            }
+            if (linkNode !== null) {
+                linkNode.append(node);
+            }
+        });
+    }
+}
+function $getLinkAncestor(node) {
+    return $getAncestor(node, (ancestor)=>$isLinkNode(ancestor));
+}
+function $getAncestor(node, predicate) {
+    let parent = node;
+    while(parent !== null && (parent = parent.getParent()) !== null && !predicate(parent));
+    return parent;
+}
+function manageRel(input, action, value) {
+    let result;
+    let mutableInput = `${input}`;
+    if (action === 'add') {
+        // if we somehow got out of sync - clean up
+        if (mutableInput.includes(value)) {
+            const re = new RegExp(value, 'g');
+            mutableInput = mutableInput.replace(re, '').trim();
+        }
+        mutableInput = mutableInput.trim();
+        result = mutableInput.length === 0 ? `${value}` : `${mutableInput} ${value}`;
+    } else {
+        const re = new RegExp(value, 'g');
+        result = mutableInput.replace(re, '').trim();
+    }
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Link/nodes/LinkNode.tsx"],"sourcesContent":["/** @module @lexical/link */\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { addClassNamesToElement, isHTMLAnchorElement } from '@lexical/utils'\nimport {\n  $applyNodeReplacement,\n  $createTextNode,\n  $getSelection,\n  $isElementNode,\n  $isRangeSelection,\n  type DOMConversionMap,\n  type DOMConversionOutput,\n  type EditorConfig,\n  ElementNode,\n  type GridSelection,\n  type LexicalCommand,\n  type LexicalNode,\n  type NodeKey,\n  type NodeSelection,\n  type RangeSelection,\n  type SerializedElementNode,\n  type Spread,\n  createCommand,\n} from 'lexical'\n\nimport type { LinkPayload } from '../plugins/floatingLinkEditor/types'\n\nexport type LinkFields = {\n  // unknown, custom fields:\n  [key: string]: unknown\n  doc: {\n    data?: any // Will be populated in afterRead hook\n    relationTo: string\n    value: string\n  } | null\n  linkType: 'custom' | 'internal'\n  newTab: boolean\n  url: string\n}\n\nexport type SerializedLinkNode = Spread<\n  {\n    fields: LinkFields\n  },\n  SerializedElementNode\n>\n\nconst SUPPORTED_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'sms:', 'tel:'])\n\n/** @noInheritDoc */\nexport class LinkNode extends ElementNode {\n  __fields: LinkFields\n\n  constructor({\n    fields = {\n      doc: null,\n      linkType: 'custom',\n      newTab: false,\n      url: undefined,\n    },\n    key,\n  }: {\n    fields: LinkFields\n    key?: NodeKey\n  }) {\n    super(key)\n    this.__fields = fields\n  }\n\n  static clone(node: LinkNode): LinkNode {\n    return new LinkNode({\n      fields: node.__fields,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'link'\n  }\n\n  static importDOM(): DOMConversionMap | null {\n    return {\n      a: (node: Node) => ({\n        conversion: convertAnchorElement,\n        priority: 1,\n      }),\n    }\n  }\n\n  static importJSON(serializedNode: SerializedLinkNode): LinkNode {\n    const node = $createLinkNode({\n      fields: serializedNode.fields,\n    })\n    node.setFormat(serializedNode.format)\n    node.setIndent(serializedNode.indent)\n    node.setDirection(serializedNode.direction)\n    return node\n  }\n\n  canBeEmpty(): false {\n    return false\n  }\n\n  canInsertTextAfter(): false {\n    return false\n  }\n\n  canInsertTextBefore(): false {\n    return false\n  }\n\n  createDOM(config: EditorConfig): HTMLAnchorElement {\n    const element = document.createElement('a')\n    if (this.__fields?.linkType === 'custom') {\n      element.href = this.sanitizeUrl(this.__fields.url ?? '')\n    }\n    if (this.__fields?.newTab ?? false) {\n      element.target = '_blank'\n    }\n\n    element.rel = ''\n\n    if (this.__fields?.newTab === true && this.__fields?.linkType === 'custom') {\n      element.rel = manageRel(element.rel, 'add', 'noopener')\n    }\n\n    if (this.__fields?.sponsored ?? false) {\n      element.rel = manageRel(element.rel, 'add', 'sponsored')\n    }\n\n    if (this.__fields?.nofollow ?? false) {\n      element.rel = manageRel(element.rel, 'add', 'nofollow')\n    }\n\n    if (this.__fields?.rel !== null) {\n      element.rel += ` ${this.__rel}`\n    }\n    addClassNamesToElement(element, config.theme.link)\n    return element\n  }\n\n  exportJSON(): SerializedLinkNode {\n    return {\n      ...super.exportJSON(),\n      fields: this.getFields(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  extractWithChild(\n    child: LexicalNode,\n    selection: GridSelection | NodeSelection | RangeSelection,\n    destination: 'clone' | 'html',\n  ): boolean {\n    if (!$isRangeSelection(selection)) {\n      return false\n    }\n\n    const anchorNode = selection.anchor.getNode()\n    const focusNode = selection.focus.getNode()\n\n    return (\n      this.isParentOf(anchorNode) &&\n      this.isParentOf(focusNode) &&\n      selection.getTextContent().length > 0\n    )\n  }\n\n  getFields(): LinkFields {\n    return this.getLatest().__fields\n  }\n\n  insertNewAfter(selection: RangeSelection, restoreSelection = true): ElementNode | null {\n    const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection)\n    if ($isElementNode(element)) {\n      const linkNode = $createLinkNode({ fields: this.__fields })\n      element.append(linkNode)\n      return linkNode\n    }\n    return null\n  }\n\n  isInline(): true {\n    return true\n  }\n\n  sanitizeUrl(url: string): string {\n    try {\n      const parsedUrl = new URL(url)\n      // eslint-disable-next-line no-script-url\n      if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {\n        return 'about:blank'\n      }\n    } catch (e) {\n      return 'https://'\n    }\n    return url\n  }\n\n  setFields(fields: LinkFields): void {\n    const writable = this.getWritable()\n    writable.__fields = fields\n  }\n\n  updateDOM(prevNode: LinkNode, anchor: HTMLAnchorElement, config: EditorConfig): boolean {\n    const url = this.__fields?.url\n    const newTab = this.__fields?.newTab\n    const sponsored = this.__fields?.sponsored\n    const nofollow = this.__fields?.nofollow\n    const rel = this.__fields?.rel\n    if (url != null && url !== prevNode.__fields?.url && this.__fields?.linkType === 'custom') {\n      anchor.href = url\n    }\n    if (this.__fields?.linkType === 'internal' && prevNode.__fields?.linkType === 'custom') {\n      anchor.removeAttribute('href')\n    }\n\n    // TODO: not 100% sure why we're settign rel to '' - revisit\n    // Start rel config here, then check newTab below\n    if (anchor.rel == null) {\n      anchor.rel = ''\n    }\n\n    if (newTab !== prevNode.__fields?.newTab) {\n      if (newTab ?? false) {\n        anchor.target = '_blank'\n        if (this.__fields?.linkType === 'custom') {\n          anchor.rel = manageRel(anchor.rel, 'add', 'noopener')\n        }\n      } else {\n        anchor.removeAttribute('target')\n        anchor.rel = manageRel(anchor.rel, 'remove', 'noopener')\n      }\n    }\n\n    if (nofollow !== prevNode.__fields.nofollow) {\n      if (nofollow ?? false) {\n        anchor.rel = manageRel(anchor.rel, 'add', 'nofollow')\n      } else {\n        anchor.rel = manageRel(anchor.rel, 'remove', 'nofollow')\n      }\n    }\n\n    if (sponsored !== prevNode.__fields.sponsored) {\n      if (sponsored ?? false) {\n        anchor.rel = manageRel(anchor.rel, 'add', 'sponsored')\n      } else {\n        anchor.rel = manageRel(anchor.rel, 'remove', 'sponsored')\n      }\n    }\n\n    // TODO - revisit - I don't think there can be any other rel\n    // values other than nofollow and noopener - so not\n    // sure why anchor.rel += rel below\n    if (rel !== prevNode.__fields.rel) {\n      if (rel != null) {\n        anchor.rel += rel\n      } else {\n        anchor.removeAttribute('rel')\n      }\n    }\n\n    return false\n  }\n}\n\nfunction convertAnchorElement(domNode: Node): DOMConversionOutput {\n  let node: LinkNode | null = null\n  if (isHTMLAnchorElement(domNode)) {\n    const content = domNode.textContent\n    if (content !== null && content !== '') {\n      node = $createLinkNode({\n        fields: {\n          doc: null,\n          linkType: 'custom',\n          newTab: domNode.getAttribute('target') === '_blank',\n          nofollow: domNode.getAttribute('rel')?.includes('nofollow') ?? false,\n          rel: domNode.getAttribute('rel'),\n          sponsored: domNode.getAttribute('rel')?.includes('sponsored') ?? false,\n          url: domNode.getAttribute('href') ?? '',\n        },\n      })\n    }\n  }\n  return { node }\n}\n\nexport function $createLinkNode({ fields }: { fields: LinkFields }): LinkNode {\n  return $applyNodeReplacement(new LinkNode({ fields }))\n}\n\nexport function $isLinkNode(node: LexicalNode | null | undefined): node is LinkNode {\n  return node instanceof LinkNode\n}\n\nexport const TOGGLE_LINK_COMMAND: LexicalCommand<LinkPayload | null> =\n  createCommand('TOGGLE_LINK_COMMAND')\n\nexport function toggleLink(payload: LinkPayload): void {\n  const selection = $getSelection()\n\n  if (!$isRangeSelection(selection)) {\n    return\n  }\n  const nodes = selection.extract()\n\n  if (payload === null) {\n    // Remove LinkNodes\n    nodes.forEach((node) => {\n      const parent = node.getParent()\n\n      if ($isLinkNode(parent)) {\n        const children = parent.getChildren()\n\n        for (let i = 0; i < children.length; i += 1) {\n          parent.insertBefore(children[i])\n        }\n\n        parent.remove()\n      }\n    })\n  } else {\n    // Add or merge LinkNodes\n    if (nodes.length === 1) {\n      const firstNode = nodes[0]\n      // if the first node is a LinkNode or if its\n      // parent is a LinkNode, we update the URL, target and rel.\n      const linkNode: LinkNode | null = $isLinkNode(firstNode)\n        ? firstNode\n        : $getLinkAncestor(firstNode)\n      if (linkNode !== null) {\n        linkNode.setFields(payload.fields)\n\n        if (payload.text != null && payload.text !== linkNode.getTextContent()) {\n          // remove all children and add child with new textcontent:\n          linkNode.append($createTextNode(payload.text))\n          linkNode.getChildren().forEach((child) => {\n            if (child !== linkNode.getLastChild()) {\n              child.remove()\n            }\n          })\n        }\n        return\n      }\n    }\n\n    let prevParent: ElementNode | LinkNode | null = null\n    let linkNode: LinkNode | null = null\n\n    nodes.forEach((node) => {\n      const parent = node.getParent()\n\n      if (parent === linkNode || parent === null || ($isElementNode(node) && !node.isInline())) {\n        return\n      }\n\n      if ($isLinkNode(parent)) {\n        linkNode = parent\n        parent.setFields(payload.fields)\n        if (payload.text != null && payload.text !== parent.getTextContent()) {\n          // remove all children and add child with new textcontent:\n          parent.append($createTextNode(payload.text))\n          parent.getChildren().forEach((child) => {\n            if (child !== parent.getLastChild()) {\n              child.remove()\n            }\n          })\n        }\n        return\n      }\n\n      if (!parent.is(prevParent)) {\n        prevParent = parent\n        linkNode = $createLinkNode({ fields: payload.fields })\n\n        if ($isLinkNode(parent)) {\n          if (node.getPreviousSibling() === null) {\n            parent.insertBefore(linkNode)\n          } else {\n            parent.insertAfter(linkNode)\n          }\n        } else {\n          node.insertBefore(linkNode)\n        }\n      }\n\n      if ($isLinkNode(node)) {\n        if (node.is(linkNode)) {\n          return\n        }\n        if (linkNode !== null) {\n          const children = node.getChildren()\n\n          for (let i = 0; i < children.length; i += 1) {\n            linkNode.append(children[i])\n          }\n        }\n\n        node.remove()\n        return\n      }\n\n      if (linkNode !== null) {\n        linkNode.append(node)\n      }\n    })\n  }\n}\n\nfunction $getLinkAncestor(node: LexicalNode): LinkNode | null {\n  return $getAncestor(node, (ancestor) => $isLinkNode(ancestor)) as LinkNode\n}\n\nfunction $getAncestor(\n  node: LexicalNode,\n  predicate: (ancestor: LexicalNode) => boolean,\n): LexicalNode | null {\n  let parent: LexicalNode | null = node\n  while (parent !== null && (parent = parent.getParent()) !== null && !predicate(parent));\n  return parent\n}\n\nfunction manageRel(input: string, action: 'add' | 'remove', value: string): string {\n  let result: string\n  let mutableInput = `${input}`\n  if (action === 'add') {\n    // if we somehow got out of sync - clean up\n    if (mutableInput.includes(value)) {\n      const re = new RegExp(value, 'g')\n      mutableInput = mutableInput.replace(re, '').trim()\n    }\n    mutableInput = mutableInput.trim()\n    result = mutableInput.length === 0 ? `${value}` : `${mutableInput} ${value}`\n  } else {\n    const re = new RegExp(value, 'g')\n    result = mutableInput.replace(re, '').trim()\n  }\n  return result\n}\n"],"names":["LinkNode","$createLinkNode","$isLinkNode","TOGGLE_LINK_COMMAND","toggleLink","SUPPORTED_URL_PROTOCOLS","Set","ElementNode","__fields","constructor","fields","doc","linkType","newTab","url","undefined","key","clone","node","__key","getType","importDOM","a","conversion","convertAnchorElement","priority","importJSON","serializedNode","setFormat","format","setIndent","indent","setDirection","direction","canBeEmpty","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","href","sanitizeUrl","target","rel","manageRel","sponsored","nofollow","__rel","addClassNamesToElement","theme","link","exportJSON","getFields","type","version","extractWithChild","child","selection","destination","$isRangeSelection","anchorNode","anchor","getNode","focusNode","focus","isParentOf","getTextContent","length","getLatest","insertNewAfter","restoreSelection","getParentOrThrow","$isElementNode","linkNode","append","isInline","parsedUrl","URL","has","protocol","e","setFields","writable","getWritable","updateDOM","prevNode","removeAttribute","domNode","isHTMLAnchorElement","content","textContent","getAttribute","includes","$applyNodeReplacement","createCommand","payload","$getSelection","nodes","extract","forEach","parent","getParent","children","getChildren","i","insertBefore","remove","firstNode","$getLinkAncestor","text","$createTextNode","getLastChild","prevParent","is","getPreviousSibling","insertAfter","$getAncestor","ancestor","predicate","input","action","value","result","mutableInput","re","RegExp","replace","trim"],"mappings":"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"}

package/dist/field/features/Link/plugins/autoLink/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ */
+/// <reference types="react" />
+import { type LinkFields } from '../../nodes/LinkNode';
+interface LinkMatcherResult {
+    fields?: LinkFields;
+    index: number;
+    length: number;
+    text: string;
+    url: string;
+}
+export type LinkMatcher = (text: string) => LinkMatcherResult | null;
+export declare function createLinkMatcherWithRegExp(regExp: RegExp, urlTransformer?: (text: string) => string): (text: string) => {
+    index: number;
+    length: number;
+    text: string;
+    url: string;
+};
+export declare function AutoLinkPlugin(): JSX.Element | null;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Link/plugins/autoLink/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/Link/plugins/autoLink/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAWH,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAInE,UAAU,iBAAiB;IACzB,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,IAAI,CAAA;AAEpE,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAuB,UAE3C,MAAM;;;;;EAUrB;AA+PD,wBAAgB,cAAc,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAMnD"}