@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.19

package/dist/field/features/link/plugins/floatingLinkEditor/LinkEditor/index.js

@@ -0,0 +1,243 @@
+'use client';
+import { useModal } from '@faceless-ui/modal';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $findMatchingParent, mergeRegister } from '@lexical/utils';
+import { getTranslation } from '@payloadcms/translations';
+import { formatDrawerSlug, useConfig, useEditDepth, useTranslation } from '@payloadcms/ui';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, KEY_ESCAPE_COMMAND, SELECTION_CHANGE_COMMAND } from 'lexical';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useEditorConfigContext } from '../../../../../lexical/config/client/EditorConfigProvider';
+import { getSelectedNode } from '../../../../../lexical/utils/getSelectedNode';
+import { setFloatingElemPositionForLinkEditor } from '../../../../../lexical/utils/setFloatingElemPositionForLinkEditor';
+import { LinkDrawer } from '../../../drawer';
+import { $isAutoLinkNode } from '../../../nodes/AutoLinkNode';
+import { $createLinkNode } from '../../../nodes/LinkNode';
+import { $isLinkNode, TOGGLE_LINK_COMMAND } from '../../../nodes/LinkNode';
+import { TOGGLE_LINK_WITH_MODAL_COMMAND } from './commands';
+export function LinkEditor({ anchorElem }) {
+    const [editor] = useLexicalComposerContext();
+    const editorRef = useRef(null);
+    const [linkUrl, setLinkUrl] = useState('');
+    const [linkLabel, setLinkLabel] = useState('');
+    const { uuid } = useEditorConfigContext();
+    const config = useConfig();
+    const { i18n, t } = useTranslation();
+    const [stateData, setStateData] = useState(null);
+    const { closeModal, toggleModal } = useModal();
+    const editDepth = useEditDepth();
+    const [isLink, setIsLink] = useState(false);
+    const [isAutoLink, setIsAutoLink] = useState(false);
+    const drawerSlug = formatDrawerSlug({
+        slug: `lexical-rich-text-link-` + uuid,
+        depth: editDepth
+    });
+    const updateLinkEditor = useCallback(()=>{
+        const selection = $getSelection();
+        let selectedNodeDomRect = null;
+        // Handle the data displayed in the floating link editor & drawer when you click on a link node
+        if ($isRangeSelection(selection)) {
+            const node = getSelectedNode(selection);
+            selectedNodeDomRect = editor.getElementByKey(node.getKey())?.getBoundingClientRect();
+            const linkParent = $findMatchingParent(node, $isLinkNode);
+            if (linkParent == null) {
+                setIsLink(false);
+                setIsAutoLink(false);
+                setLinkUrl('');
+                setLinkLabel('');
+                return;
+            }
+            // Initial state:
+            const data = {
+                fields: {
+                    doc: undefined,
+                    linkType: undefined,
+                    newTab: undefined,
+                    url: '',
+                    ...linkParent.getFields()
+                },
+                text: linkParent.getTextContent()
+            };
+            if (linkParent.getFields()?.linkType === 'custom') {
+                setLinkUrl(linkParent.getFields()?.url ?? '');
+                setLinkLabel('');
+            } else {
+                // internal link
+                setLinkUrl(`/admin/collections/${linkParent.getFields()?.doc?.relationTo}/${linkParent.getFields()?.doc?.value}`);
+                const relatedField = config.collections.find((coll)=>coll.slug === linkParent.getFields()?.doc?.relationTo);
+                const label = t('fields:linkedTo', {
+                    label: getTranslation(relatedField.labels.singular, i18n)
+                }).replace(/<[^>]*>?/g, '');
+                setLinkLabel(label);
+            }
+            setStateData(data);
+            setIsLink(true);
+            if ($isAutoLinkNode(linkParent)) {
+                setIsAutoLink(true);
+            } else {
+                setIsAutoLink(false);
+            }
+        }
+        const editorElem = editorRef.current;
+        const nativeSelection = window.getSelection();
+        const { activeElement } = document;
+        if (editorElem === null) {
+            return;
+        }
+        const rootElement = editor.getRootElement();
+        if (selection !== null && nativeSelection !== null && rootElement !== null && rootElement.contains(nativeSelection.anchorNode)) {
+            if (!selectedNodeDomRect) {
+                // Get the DOM rect of the selected node using the native selection. This sometimes produces the wrong
+                // result, which is why we use lexical's selection preferably.
+                selectedNodeDomRect = nativeSelection.getRangeAt(0).getBoundingClientRect();
+            }
+            if (selectedNodeDomRect != null) {
+                selectedNodeDomRect.y += 40;
+                setFloatingElemPositionForLinkEditor(selectedNodeDomRect, editorElem, anchorElem);
+            }
+        } else if (activeElement == null || activeElement.className !== 'link-input') {
+            if (rootElement !== null) {
+                setFloatingElemPositionForLinkEditor(null, editorElem, anchorElem);
+            }
+            setLinkUrl('');
+            setLinkLabel('');
+        }
+        return true;
+    }, [
+        anchorElem,
+        editor,
+        config,
+        t,
+        i18n
+    ]);
+    useEffect(()=>{
+        return mergeRegister(editor.registerCommand(TOGGLE_LINK_WITH_MODAL_COMMAND, (payload)=>{
+            editor.dispatchCommand(TOGGLE_LINK_COMMAND, payload);
+            // Now, open the modal
+            updateLinkEditor();
+            toggleModal(drawerSlug);
+            return true;
+        }, COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        updateLinkEditor,
+        toggleModal,
+        drawerSlug
+    ]);
+    useEffect(()=>{
+        if (!isLink && editorRef) {
+            editorRef.current.style.opacity = '0';
+            editorRef.current.style.transform = 'translate(-10000px, -10000px)';
+        }
+    }, [
+        isLink
+    ]);
+    useEffect(()=>{
+        const scrollerElem = anchorElem.parentElement;
+        const update = ()=>{
+            editor.getEditorState().read(()=>{
+                void updateLinkEditor();
+            });
+        };
+        window.addEventListener('resize', update);
+        if (scrollerElem != null) {
+            scrollerElem.addEventListener('scroll', update);
+        }
+        return ()=>{
+            window.removeEventListener('resize', update);
+            if (scrollerElem != null) {
+                scrollerElem.removeEventListener('scroll', update);
+            }
+        };
+    }, [
+        anchorElem.parentElement,
+        editor,
+        updateLinkEditor
+    ]);
+    useEffect(()=>{
+        return mergeRegister(editor.registerUpdateListener(({ editorState })=>{
+            editorState.read(()=>{
+                void updateLinkEditor();
+            });
+        }), editor.registerCommand(SELECTION_CHANGE_COMMAND, ()=>{
+            void updateLinkEditor();
+            return true;
+        }, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ESCAPE_COMMAND, ()=>{
+            if (isLink) {
+                setIsLink(false);
+                setIsAutoLink(false);
+                return true;
+            }
+            return false;
+        }, COMMAND_PRIORITY_HIGH));
+    }, [
+        editor,
+        updateLinkEditor,
+        setIsLink,
+        isLink
+    ]);
+    useEffect(()=>{
+        editor.getEditorState().read(()=>{
+            void updateLinkEditor();
+        });
+    }, [
+        editor,
+        updateLinkEditor
+    ]);
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("div", {
+        className: "link-editor",
+        ref: editorRef
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: "link-input"
+    }, /*#__PURE__*/ React.createElement("a", {
+        href: linkUrl,
+        rel: "noopener noreferrer",
+        target: "_blank"
+    }, linkLabel != null && linkLabel.length > 0 ? linkLabel : linkUrl), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("button", {
+        "aria-label": "Edit link",
+        className: "link-edit",
+        onClick: ()=>{
+            toggleModal(drawerSlug);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    }), !isAutoLink && /*#__PURE__*/ React.createElement("button", {
+        "aria-label": "Remove link",
+        className: "link-trash",
+        onClick: ()=>{
+            editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    })))), /*#__PURE__*/ React.createElement(LinkDrawer, {
+        drawerSlug: drawerSlug,
+        handleModalSubmit: (fields, data)=>{
+            closeModal(drawerSlug);
+            const newLinkPayload = data;
+            // See: https://github.com/facebook/lexical/pull/5536. This updates autolink nodes to link nodes whenever a change was made (which is good!).
+            editor.update(()=>{
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    const parent = getSelectedNode(selection).getParent();
+                    if ($isAutoLinkNode(parent)) {
+                        const linkNode = $createLinkNode({
+                            fields: newLinkPayload.fields
+                        });
+                        parent.replace(linkNode, true);
+                    }
+                }
+            });
+            // Needs to happen AFTER a potential auto link => link node conversion, as otherwise, the updated text to display may be lost due to
+            // it being applied to the auto link node instead of the link node.
+            editor.dispatchCommand(TOGGLE_LINK_COMMAND, newLinkPayload);
+        },
+        stateData: stateData
+    }));
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/field/features/link/plugins/floatingLinkEditor/LinkEditor/index.tsx"],"sourcesContent":["'use client'\nimport type { FormState } from 'payload/types'\nimport type { Data } from 'payload/types'\n\nimport { useModal } from '@faceless-ui/modal'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { $findMatchingParent, mergeRegister } from '@lexical/utils'\nimport { getTranslation } from '@payloadcms/translations'\nimport { formatDrawerSlug, useConfig, useEditDepth, useTranslation } from '@payloadcms/ui'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  COMMAND_PRIORITY_HIGH,\n  COMMAND_PRIORITY_LOW,\n  KEY_ESCAPE_COMMAND,\n  SELECTION_CHANGE_COMMAND,\n} from 'lexical'\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\n\nimport type { LinkNode } from '../../../nodes/LinkNode'\nimport type { LinkPayload } from '../types'\n\nimport { useEditorConfigContext } from '../../../../../lexical/config/client/EditorConfigProvider'\nimport { getSelectedNode } from '../../../../../lexical/utils/getSelectedNode'\nimport { setFloatingElemPositionForLinkEditor } from '../../../../../lexical/utils/setFloatingElemPositionForLinkEditor'\nimport { LinkDrawer } from '../../../drawer'\nimport { $isAutoLinkNode } from '../../../nodes/AutoLinkNode'\nimport { $createLinkNode } from '../../../nodes/LinkNode'\nimport { $isLinkNode, TOGGLE_LINK_COMMAND } from '../../../nodes/LinkNode'\nimport { TOGGLE_LINK_WITH_MODAL_COMMAND } from './commands'\n\nexport function LinkEditor({ anchorElem }: { anchorElem: HTMLElement }): React.ReactNode {\n  const [editor] = useLexicalComposerContext()\n\n  const editorRef = useRef<HTMLDivElement | null>(null)\n  const [linkUrl, setLinkUrl] = useState('')\n  const [linkLabel, setLinkLabel] = useState('')\n\n  const { uuid } = useEditorConfigContext()\n\n  const config = useConfig()\n\n  const { i18n, t } = useTranslation()\n\n  const [stateData, setStateData] = useState<LinkPayload>(null)\n\n  const { closeModal, toggleModal } = useModal()\n  const editDepth = useEditDepth()\n  const [isLink, setIsLink] = useState(false)\n  const [isAutoLink, setIsAutoLink] = useState(false)\n\n  const drawerSlug = formatDrawerSlug({\n    slug: `lexical-rich-text-link-` + uuid,\n    depth: editDepth,\n  })\n\n  const updateLinkEditor = useCallback(() => {\n    const selection = $getSelection()\n    let selectedNodeDomRect: DOMRect | undefined = null\n\n    // Handle the data displayed in the floating link editor & drawer when you click on a link node\n    if ($isRangeSelection(selection)) {\n      const node = getSelectedNode(selection)\n      selectedNodeDomRect = editor.getElementByKey(node.getKey())?.getBoundingClientRect()\n      const linkParent: LinkNode = $findMatchingParent(node, $isLinkNode)\n      if (linkParent == null) {\n        setIsLink(false)\n        setIsAutoLink(false)\n        setLinkUrl('')\n        setLinkLabel('')\n        return\n      }\n\n      // Initial state:\n      const data: LinkPayload = {\n        fields: {\n          doc: undefined,\n          linkType: undefined,\n          newTab: undefined,\n          url: '',\n          ...linkParent.getFields(),\n        },\n        text: linkParent.getTextContent(),\n      }\n\n      if (linkParent.getFields()?.linkType === 'custom') {\n        setLinkUrl(linkParent.getFields()?.url ?? '')\n        setLinkLabel('')\n      } else {\n        // internal link\n        setLinkUrl(\n          `/admin/collections/${linkParent.getFields()?.doc?.relationTo}/${\n            linkParent.getFields()?.doc?.value\n          }`,\n        )\n\n        const relatedField = config.collections.find(\n          (coll) => coll.slug === linkParent.getFields()?.doc?.relationTo,\n        )\n        const label = t('fields:linkedTo', {\n          label: getTranslation(relatedField.labels.singular, i18n),\n        }).replace(/<[^>]*>?/g, '')\n        setLinkLabel(label)\n      }\n\n      setStateData(data)\n      setIsLink(true)\n      if ($isAutoLinkNode(linkParent)) {\n        setIsAutoLink(true)\n      } else {\n        setIsAutoLink(false)\n      }\n    }\n\n    const editorElem = editorRef.current\n    const nativeSelection = window.getSelection()\n    const { activeElement } = document\n\n    if (editorElem === null) {\n      return\n    }\n\n    const rootElement = editor.getRootElement()\n\n    if (\n      selection !== null &&\n      nativeSelection !== null &&\n      rootElement !== null &&\n      rootElement.contains(nativeSelection.anchorNode)\n    ) {\n      if (!selectedNodeDomRect) {\n        // Get the DOM rect of the selected node using the native selection. This sometimes produces the wrong\n        // result, which is why we use lexical's selection preferably.\n        selectedNodeDomRect = nativeSelection.getRangeAt(0).getBoundingClientRect()\n      }\n\n      if (selectedNodeDomRect != null) {\n        selectedNodeDomRect.y += 40\n        setFloatingElemPositionForLinkEditor(selectedNodeDomRect, editorElem, anchorElem)\n      }\n    } else if (activeElement == null || activeElement.className !== 'link-input') {\n      if (rootElement !== null) {\n        setFloatingElemPositionForLinkEditor(null, editorElem, anchorElem)\n      }\n      setLinkUrl('')\n      setLinkLabel('')\n    }\n\n    return true\n  }, [anchorElem, editor, config, t, i18n])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        TOGGLE_LINK_WITH_MODAL_COMMAND,\n        (payload: LinkPayload) => {\n          editor.dispatchCommand(TOGGLE_LINK_COMMAND, payload)\n\n          // Now, open the modal\n          updateLinkEditor()\n          toggleModal(drawerSlug)\n\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, updateLinkEditor, toggleModal, drawerSlug])\n\n  useEffect(() => {\n    if (!isLink && editorRef) {\n      editorRef.current.style.opacity = '0'\n      editorRef.current.style.transform = 'translate(-10000px, -10000px)'\n    }\n  }, [isLink])\n\n  useEffect(() => {\n    const scrollerElem = anchorElem.parentElement\n\n    const update = (): void => {\n      editor.getEditorState().read(() => {\n        void updateLinkEditor()\n      })\n    }\n\n    window.addEventListener('resize', update)\n\n    if (scrollerElem != null) {\n      scrollerElem.addEventListener('scroll', update)\n    }\n\n    return () => {\n      window.removeEventListener('resize', update)\n\n      if (scrollerElem != null) {\n        scrollerElem.removeEventListener('scroll', update)\n      }\n    }\n  }, [anchorElem.parentElement, editor, updateLinkEditor])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(({ editorState }) => {\n        editorState.read(() => {\n          void updateLinkEditor()\n        })\n      }),\n\n      editor.registerCommand(\n        SELECTION_CHANGE_COMMAND,\n        () => {\n          void updateLinkEditor()\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand(\n        KEY_ESCAPE_COMMAND,\n        () => {\n          if (isLink) {\n            setIsLink(false)\n            setIsAutoLink(false)\n            return true\n          }\n          return false\n        },\n        COMMAND_PRIORITY_HIGH,\n      ),\n    )\n  }, [editor, updateLinkEditor, setIsLink, isLink])\n\n  useEffect(() => {\n    editor.getEditorState().read(() => {\n      void updateLinkEditor()\n    })\n  }, [editor, updateLinkEditor])\n\n  return (\n    <React.Fragment>\n      <div className=\"link-editor\" ref={editorRef}>\n        <div className=\"link-input\">\n          <a href={linkUrl} rel=\"noopener noreferrer\" target=\"_blank\">\n            {linkLabel != null && linkLabel.length > 0 ? linkLabel : linkUrl}\n          </a>\n          {editor.isEditable() && (\n            <React.Fragment>\n              <button\n                aria-label=\"Edit link\"\n                className=\"link-edit\"\n                onClick={() => {\n                  toggleModal(drawerSlug)\n                }}\n                onMouseDown={(event) => {\n                  event.preventDefault()\n                }}\n                tabIndex={0}\n                type=\"button\"\n              />\n              {!isAutoLink && (\n                <button\n                  aria-label=\"Remove link\"\n                  className=\"link-trash\"\n                  onClick={() => {\n                    editor.dispatchCommand(TOGGLE_LINK_COMMAND, null)\n                  }}\n                  onMouseDown={(event) => {\n                    event.preventDefault()\n                  }}\n                  tabIndex={0}\n                  type=\"button\"\n                />\n              )}\n            </React.Fragment>\n          )}\n        </div>\n      </div>\n      <LinkDrawer\n        drawerSlug={drawerSlug}\n        handleModalSubmit={(fields: FormState, data: Data) => {\n          closeModal(drawerSlug)\n\n          const newLinkPayload: LinkPayload = data as LinkPayload\n\n          // See: https://github.com/facebook/lexical/pull/5536. This updates autolink nodes to link nodes whenever a change was made (which is good!).\n          editor.update(() => {\n            const selection = $getSelection()\n            if ($isRangeSelection(selection)) {\n              const parent = getSelectedNode(selection).getParent()\n              if ($isAutoLinkNode(parent)) {\n                const linkNode = $createLinkNode({\n                  fields: newLinkPayload.fields,\n                })\n                parent.replace(linkNode, true)\n              }\n            }\n          })\n\n          // Needs to happen AFTER a potential auto link => link node conversion, as otherwise, the updated text to display may be lost due to\n          // it being applied to the auto link node instead of the link node.\n          editor.dispatchCommand(TOGGLE_LINK_COMMAND, newLinkPayload)\n        }}\n        stateData={stateData}\n      />\n    </React.Fragment>\n  )\n}\n"],"names":["useModal","useLexicalComposerContext","$findMatchingParent","mergeRegister","getTranslation","formatDrawerSlug","useConfig","useEditDepth","useTranslation","$getSelection","$isRangeSelection","COMMAND_PRIORITY_HIGH","COMMAND_PRIORITY_LOW","KEY_ESCAPE_COMMAND","SELECTION_CHANGE_COMMAND","React","useCallback","useEffect","useRef","useState","useEditorConfigContext","getSelectedNode","setFloatingElemPositionForLinkEditor","LinkDrawer","$isAutoLinkNode","$createLinkNode","$isLinkNode","TOGGLE_LINK_COMMAND","TOGGLE_LINK_WITH_MODAL_COMMAND","LinkEditor","anchorElem","editor","editorRef","linkUrl","setLinkUrl","linkLabel","setLinkLabel","uuid","config","i18n","t","stateData","setStateData","closeModal","toggleModal","editDepth","isLink","setIsLink","isAutoLink","setIsAutoLink","drawerSlug","slug","depth","updateLinkEditor","selection","selectedNodeDomRect","node","getElementByKey","getKey","getBoundingClientRect","linkParent","data","fields","doc","undefined","linkType","newTab","url","getFields","text","getTextContent","relationTo","value","relatedField","collections","find","coll","label","labels","singular","replace","editorElem","current","nativeSelection","window","getSelection","activeElement","document","rootElement","getRootElement","contains","anchorNode","getRangeAt","y","className","registerCommand","payload","dispatchCommand","style","opacity","transform","scrollerElem","parentElement","update","getEditorState","read","addEventListener","removeEventListener","registerUpdateListener","editorState","Fragment","div","ref","a","href","rel","target","length","isEditable","button","aria-label","onClick","onMouseDown","event","preventDefault","tabIndex","type","handleModalSubmit","newLinkPayload","parent","getParent","linkNode"],"mappings":"AAAA;AAIA,SAASA,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,yBAAyB,QAAQ,wCAAuC;AACjF,SAASC,mBAAmB,EAAEC,aAAa,QAAQ,iBAAgB;AACnE,SAASC,cAAc,QAAQ,2BAA0B;AACzD,SAASC,gBAAgB,EAAEC,SAAS,EAAEC,YAAY,EAAEC,cAAc,QAAQ,iBAAgB;AAC1F,SACEC,aAAa,EACbC,iBAAiB,EACjBC,qBAAqB,EACrBC,oBAAoB,EACpBC,kBAAkB,EAClBC,wBAAwB,QACnB,UAAS;AAChB,OAAOC,SAASC,WAAW,EAAEC,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,QAAO;AAKvE,SAASC,sBAAsB,QAAQ,4DAA2D;AAClG,SAASC,eAAe,QAAQ,+CAA8C;AAC9E,SAASC,oCAAoC,QAAQ,oEAAmE;AACxH,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,eAAe,QAAQ,0BAAyB;AACzD,SAASC,WAAW,EAAEC,mBAAmB,QAAQ,0BAAyB;AAC1E,SAASC,8BAA8B,QAAQ,aAAY;AAE3D,OAAO,SAASC,WAAW,EAAEC,UAAU,EAA+B;IACpE,MAAM,CAACC,OAAO,GAAG9B;IAEjB,MAAM+B,YAAYd,OAA8B;IAChD,MAAM,CAACe,SAASC,WAAW,GAAGf,SAAS;IACvC,MAAM,CAACgB,WAAWC,aAAa,GAAGjB,SAAS;IAE3C,MAAM,EAAEkB,IAAI,EAAE,GAAGjB;IAEjB,MAAMkB,SAAShC;IAEf,MAAM,EAAEiC,IAAI,EAAEC,CAAC,EAAE,GAAGhC;IAEpB,MAAM,CAACiC,WAAWC,aAAa,GAAGvB,SAAsB;IAExD,MAAM,EAAEwB,UAAU,EAAEC,WAAW,EAAE,GAAG5C;IACpC,MAAM6C,YAAYtC;IAClB,MAAM,CAACuC,QAAQC,UAAU,GAAG5B,SAAS;IACrC,MAAM,CAAC6B,YAAYC,cAAc,GAAG9B,SAAS;IAE7C,MAAM+B,aAAa7C,iBAAiB;QAClC8C,MAAM,CAAC,uBAAuB,CAAC,GAAGd;QAClCe,OAAOP;IACT;IAEA,MAAMQ,mBAAmBrC,YAAY;QACnC,MAAMsC,YAAY7C;QAClB,IAAI8C,sBAA2C;QAE/C,+FAA+F;QAC/F,IAAI7C,kBAAkB4C,YAAY;YAChC,MAAME,OAAOnC,gBAAgBiC;YAC7BC,sBAAsBxB,OAAO0B,eAAe,CAACD,KAAKE,MAAM,KAAKC;YAC7D,MAAMC,aAAuB1D,oBAAoBsD,MAAM9B;YACvD,IAAIkC,cAAc,MAAM;gBACtBb,UAAU;gBACVE,cAAc;gBACdf,WAAW;gBACXE,aAAa;gBACb;YACF;YAEA,iBAAiB;YACjB,MAAMyB,OAAoB;gBACxBC,QAAQ;oBACNC,KAAKC;oBACLC,UAAUD;oBACVE,QAAQF;oBACRG,KAAK;oBACL,GAAGP,WAAWQ,SAAS,EAAE;gBAC3B;gBACAC,MAAMT,WAAWU,cAAc;YACjC;YAEA,IAAIV,WAAWQ,SAAS,IAAIH,aAAa,UAAU;gBACjD/B,WAAW0B,WAAWQ,SAAS,IAAID,OAAO;gBAC1C/B,aAAa;YACf,OAAO;gBACL,gBAAgB;gBAChBF,WACE,CAAC,mBAAmB,EAAE0B,WAAWQ,SAAS,IAAIL,KAAKQ,WAAW,CAAC,EAC7DX,WAAWQ,SAAS,IAAIL,KAAKS,MAC9B,CAAC;gBAGJ,MAAMC,eAAenC,OAAOoC,WAAW,CAACC,IAAI,CAC1C,CAACC,OAASA,KAAKzB,IAAI,KAAKS,WAAWQ,SAAS,IAAIL,KAAKQ;gBAEvD,MAAMM,QAAQrC,EAAE,mBAAmB;oBACjCqC,OAAOzE,eAAeqE,aAAaK,MAAM,CAACC,QAAQ,EAAExC;gBACtD,GAAGyC,OAAO,CAAC,aAAa;gBACxB5C,aAAayC;YACf;YAEAnC,aAAamB;YACbd,UAAU;YACV,IAAIvB,gBAAgBoC,aAAa;gBAC/BX,cAAc;YAChB,OAAO;gBACLA,cAAc;YAChB;QACF;QAEA,MAAMgC,aAAajD,UAAUkD,OAAO;QACpC,MAAMC,kBAAkBC,OAAOC,YAAY;QAC3C,MAAM,EAAEC,aAAa,EAAE,GAAGC;QAE1B,IAAIN,eAAe,MAAM;YACvB;QACF;QAEA,MAAMO,cAAczD,OAAO0D,cAAc;QAEzC,IACEnC,cAAc,QACd6B,oBAAoB,QACpBK,gBAAgB,QAChBA,YAAYE,QAAQ,CAACP,gBAAgBQ,UAAU,GAC/C;YACA,IAAI,CAACpC,qBAAqB;gBACxB,sGAAsG;gBACtG,8DAA8D;gBAC9DA,sBAAsB4B,gBAAgBS,UAAU,CAAC,GAAGjC,qBAAqB;YAC3E;YAEA,IAAIJ,uBAAuB,MAAM;gBAC/BA,oBAAoBsC,CAAC,IAAI;gBACzBvE,qCAAqCiC,qBAAqB0B,YAAYnD;YACxE;QACF,OAAO,IAAIwD,iBAAiB,QAAQA,cAAcQ,SAAS,KAAK,cAAc;YAC5E,IAAIN,gBAAgB,MAAM;gBACxBlE,qCAAqC,MAAM2D,YAAYnD;YACzD;YACAI,WAAW;YACXE,aAAa;QACf;QAEA,OAAO;IACT,GAAG;QAACN;QAAYC;QAAQO;QAAQE;QAAGD;KAAK;IAExCtB,UAAU;QACR,OAAOd,cACL4B,OAAOgE,eAAe,CACpBnE,gCACA,CAACoE;YACCjE,OAAOkE,eAAe,CAACtE,qBAAqBqE;YAE5C,sBAAsB;YACtB3C;YACAT,YAAYM;YAEZ,OAAO;QACT,GACAtC;IAGN,GAAG;QAACmB;QAAQsB;QAAkBT;QAAaM;KAAW;IAEtDjC,UAAU;QACR,IAAI,CAAC6B,UAAUd,WAAW;YACxBA,UAAUkD,OAAO,CAACgB,KAAK,CAACC,OAAO,GAAG;YAClCnE,UAAUkD,OAAO,CAACgB,KAAK,CAACE,SAAS,GAAG;QACtC;IACF,GAAG;QAACtD;KAAO;IAEX7B,UAAU;QACR,MAAMoF,eAAevE,WAAWwE,aAAa;QAE7C,MAAMC,SAAS;YACbxE,OAAOyE,cAAc,GAAGC,IAAI,CAAC;gBAC3B,KAAKpD;YACP;QACF;QAEA+B,OAAOsB,gBAAgB,CAAC,UAAUH;QAElC,IAAIF,gBAAgB,MAAM;YACxBA,aAAaK,gBAAgB,CAAC,UAAUH;QAC1C;QAEA,OAAO;YACLnB,OAAOuB,mBAAmB,CAAC,UAAUJ;YAErC,IAAIF,gBAAgB,MAAM;gBACxBA,aAAaM,mBAAmB,CAAC,UAAUJ;YAC7C;QACF;IACF,GAAG;QAACzE,WAAWwE,aAAa;QAAEvE;QAAQsB;KAAiB;IAEvDpC,UAAU;QACR,OAAOd,cACL4B,OAAO6E,sBAAsB,CAAC,CAAC,EAAEC,WAAW,EAAE;YAC5CA,YAAYJ,IAAI,CAAC;gBACf,KAAKpD;YACP;QACF,IAEAtB,OAAOgE,eAAe,CACpBjF,0BACA;YACE,KAAKuC;YACL,OAAO;QACT,GACAzC,uBAEFmB,OAAOgE,eAAe,CACpBlF,oBACA;YACE,IAAIiC,QAAQ;gBACVC,UAAU;gBACVE,cAAc;gBACd,OAAO;YACT;YACA,OAAO;QACT,GACAtC;IAGN,GAAG;QAACoB;QAAQsB;QAAkBN;QAAWD;KAAO;IAEhD7B,UAAU;QACRc,OAAOyE,cAAc,GAAGC,IAAI,CAAC;YAC3B,KAAKpD;QACP;IACF,GAAG;QAACtB;QAAQsB;KAAiB;IAE7B,qBACE,oBAACtC,MAAM+F,QAAQ,sBACb,oBAACC;QAAIjB,WAAU;QAAckB,KAAKhF;qBAChC,oBAAC+E;QAAIjB,WAAU;qBACb,oBAACmB;QAAEC,MAAMjF;QAASkF,KAAI;QAAsBC,QAAO;OAChDjF,aAAa,QAAQA,UAAUkF,MAAM,GAAG,IAAIlF,YAAYF,UAE1DF,OAAOuF,UAAU,oBAChB,oBAACvG,MAAM+F,QAAQ,sBACb,oBAACS;QACCC,cAAW;QACX1B,WAAU;QACV2B,SAAS;YACP7E,YAAYM;QACd;QACAwE,aAAa,CAACC;YACZA,MAAMC,cAAc;QACtB;QACAC,UAAU;QACVC,MAAK;QAEN,CAAC9E,4BACA,oBAACuE;QACCC,cAAW;QACX1B,WAAU;QACV2B,SAAS;YACP1F,OAAOkE,eAAe,CAACtE,qBAAqB;QAC9C;QACA+F,aAAa,CAACC;YACZA,MAAMC,cAAc;QACtB;QACAC,UAAU;QACVC,MAAK;yBAOjB,oBAACvG;QACC2B,YAAYA;QACZ6E,mBAAmB,CAACjE,QAAmBD;YACrClB,WAAWO;YAEX,MAAM8E,iBAA8BnE;YAEpC,6IAA6I;YAC7I9B,OAAOwE,MAAM,CAAC;gBACZ,MAAMjD,YAAY7C;gBAClB,IAAIC,kBAAkB4C,YAAY;oBAChC,MAAM2E,SAAS5G,gBAAgBiC,WAAW4E,SAAS;oBACnD,IAAI1G,gBAAgByG,SAAS;wBAC3B,MAAME,WAAW1G,gBAAgB;4BAC/BqC,QAAQkE,eAAelE,MAAM;wBAC/B;wBACAmE,OAAOjD,OAAO,CAACmD,UAAU;oBAC3B;gBACF;YACF;YAEA,oIAAoI;YACpI,mEAAmE;YACnEpG,OAAOkE,eAAe,CAACtE,qBAAqBqG;QAC9C;QACAvF,WAAWA;;AAInB"}

package/dist/field/features/link/plugins/floatingLinkEditor/index.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import './index.scss';
+export declare const FloatingLinkEditorPlugin: React.FC<{
+    anchorElem: HTMLElement;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/link/plugins/floatingLinkEditor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/floatingLinkEditor/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC9C,UAAU,EAAE,WAAW,CAAA;CACxB,CAIA,CAAA"}

package/dist/field/features/link/plugins/floatingLinkEditor/index.js

@@ -0,0 +1,13 @@
+'use client';
+import * as React from 'react';
+import { createPortal } from 'react-dom';
+import { LinkEditor } from './LinkEditor';
+import './index.scss';
+export const FloatingLinkEditorPlugin = (props)=>{
+    const { anchorElem = document.body } = props;
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(LinkEditor, {
+        anchorElem: anchorElem
+    }), anchorElem);
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saW5rL3BsdWdpbnMvZmxvYXRpbmdMaW5rRWRpdG9yL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgY3JlYXRlUG9ydGFsIH0gZnJvbSAncmVhY3QtZG9tJ1xuXG5pbXBvcnQgeyBMaW5rRWRpdG9yIH0gZnJvbSAnLi9MaW5rRWRpdG9yJ1xuaW1wb3J0ICcuL2luZGV4LnNjc3MnXG5cbmV4cG9ydCBjb25zdCBGbG9hdGluZ0xpbmtFZGl0b3JQbHVnaW46IFJlYWN0LkZDPHtcbiAgYW5jaG9yRWxlbTogSFRNTEVsZW1lbnRcbn0+ID0gKHByb3BzKSA9PiB7XG4gIGNvbnN0IHsgYW5jaG9yRWxlbSA9IGRvY3VtZW50LmJvZHkgfSA9IHByb3BzXG5cbiAgcmV0dXJuIGNyZWF0ZVBvcnRhbCg8TGlua0VkaXRvciBhbmNob3JFbGVtPXthbmNob3JFbGVtfSAvPiwgYW5jaG9yRWxlbSlcbn1cbiJdLCJuYW1lcyI6WyJSZWFjdCIsImNyZWF0ZVBvcnRhbCIsIkxpbmtFZGl0b3IiLCJGbG9hdGluZ0xpbmtFZGl0b3JQbHVnaW4iLCJwcm9wcyIsImFuY2hvckVsZW0iLCJkb2N1bWVudCIsImJvZHkiXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0EsWUFBWUEsV0FBVyxRQUFPO0FBQzlCLFNBQVNDLFlBQVksUUFBUSxZQUFXO0FBRXhDLFNBQVNDLFVBQVUsUUFBUSxlQUFjO0FBQ3pDLE9BQU8sZUFBYztBQUVyQixPQUFPLE1BQU1DLDJCQUVSLENBQUNDO0lBQ0osTUFBTSxFQUFFQyxhQUFhQyxTQUFTQyxJQUFJLEVBQUUsR0FBR0g7SUFFdkMscUJBQU9ILDJCQUFhLG9CQUFDQztRQUFXRyxZQUFZQTtRQUFnQkE7QUFDOUQsRUFBQyJ9

package/dist/field/features/link/plugins/floatingLinkEditor/index.scss

@@ -0,0 +1,78 @@
+@import '../../../../../scss/styles.scss';
+
+html[data-theme='light'] {
+  .link-editor {
+    @include shadow-m;
+  }
+}
+
+.link-editor {
+  z-index: 10;
+  display: flex;
+  align-items: center;
+  background: var(--color-base-0);
+  padding: 0px 3.72px 0px 6.25px;
+  vertical-align: middle;
+  position: absolute;
+  top: 0;
+  left: 0;
+  opacity: 0;
+  border-radius: 6.25px;
+  transition: opacity 0.2s;
+  height: 37.5px;
+  will-change: transform;
+
+  .link-input {
+    display: flex;
+    align-items: center;
+    flex-direction: row;
+    flex-wrap: nowrap;
+    min-height: 28px;
+    box-sizing: border-box;
+    padding: 2px 4px;
+    font-size: 15px;
+    border: 0;
+    outline: 0;
+    position: relative;
+    font-family: var(--font-body);
+
+    a {
+      text-decoration: none;
+      display: block;
+      white-space: nowrap;
+      overflow: hidden;
+      margin-right: 30px;
+      text-overflow: ellipsis;
+      color: var(--color-blue-600);
+      border-bottom: 1px dotted;
+
+      &:hover {
+        color: var(--color-blue-400);
+      }
+    }
+  }
+
+  button {
+    all: unset;
+    background-size: 16px;
+    background-position: center;
+    background-repeat: no-repeat;
+    width: 30px;
+    height: 30px;
+    cursor: pointer;
+    color: var(--color-base-600);
+    border-radius: 4px;
+
+    &:hover:not([disabled]) {
+      background-color: var(--color-base-100);
+    }
+  }
+
+  .link-edit {
+    background-image: url(../../../../lexical/ui/icons/Edit/index.svg);
+  }
+
+  .link-trash {
+    background-image: url(../../../../lexical/ui/icons/Remove/index.svg);
+  }
+}

package/dist/field/features/link/plugins/floatingLinkEditor/types.d.ts

@@ -0,0 +1,13 @@
+import type { LinkFields } from '../../nodes/types';
+/**
+ * The payload of a link node
+ * This can be delivered from the link node to the drawer, or from the drawer/anything to the TOGGLE_LINK_COMMAND
+ */
+export type LinkPayload = {
+    fields: LinkFields;
+    /**
+     * The text content of the link node - will be displayed in the drawer
+     */
+    text: null | string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/field/features/link/plugins/floatingLinkEditor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/floatingLinkEditor/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,UAAU,CAAA;IAClB;;OAEG;IACH,IAAI,EAAE,IAAI,GAAG,MAAM,CAAA;CACpB,CAAA"}

package/dist/field/features/link/plugins/floatingLinkEditor/types.js

@@ -0,0 +1,6 @@
+/**
+ * The payload of a link node
+ * This can be delivered from the link node to the drawer, or from the drawer/anything to the TOGGLE_LINK_COMMAND
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saW5rL3BsdWdpbnMvZmxvYXRpbmdMaW5rRWRpdG9yL3R5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGlua0ZpZWxkcyB9IGZyb20gJy4uLy4uL25vZGVzL3R5cGVzJ1xuXG4vKipcbiAqIFRoZSBwYXlsb2FkIG9mIGEgbGluayBub2RlXG4gKiBUaGlzIGNhbiBiZSBkZWxpdmVyZWQgZnJvbSB0aGUgbGluayBub2RlIHRvIHRoZSBkcmF3ZXIsIG9yIGZyb20gdGhlIGRyYXdlci9hbnl0aGluZyB0byB0aGUgVE9HR0xFX0xJTktfQ09NTUFORFxuICovXG5leHBvcnQgdHlwZSBMaW5rUGF5bG9hZCA9IHtcbiAgZmllbGRzOiBMaW5rRmllbGRzXG4gIC8qKlxuICAgKiBUaGUgdGV4dCBjb250ZW50IG9mIHRoZSBsaW5rIG5vZGUgLSB3aWxsIGJlIGRpc3BsYXllZCBpbiB0aGUgZHJhd2VyXG4gICAqL1xuICB0ZXh0OiBudWxsIHwgc3RyaW5nXG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztDQUdDLEdBQ0QsV0FNQyJ9

package/dist/field/features/link/plugins/floatingLinkEditor/utilities.d.ts

@@ -0,0 +1,12 @@
+import type { I18n } from '@payloadcms/translations';
+import type { SanitizedConfig } from 'payload/config';
+import type { Field } from 'payload/types';
+/**
+ * This function is run to enrich the basefields which every link has with potential, custom user-added fields.
+ */
+export declare function transformExtraFields(customFieldSchema: ((args: {
+    config: SanitizedConfig;
+    defaultFields: Field[];
+    i18n: I18n;
+}) => Field[]) | Field[], config: SanitizedConfig, i18n: I18n, enabledCollections?: false | string[], disabledCollections?: false | string[]): Field[];
+//# sourceMappingURL=utilities.d.ts.map

package/dist/field/features/link/plugins/floatingLinkEditor/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/floatingLinkEditor/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,eAAe,CAAA;AAItD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EACb,CAAC,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,aAAa,EAAE,KAAK,EAAE,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,KAAK,KAAK,EAAE,CAAC,GACpF,KAAK,EAAE,EACX,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,IAAI,EACV,kBAAkB,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,EACrC,mBAAmB,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,GACrC,KAAK,EAAE,CA0CT"}

package/dist/field/features/link/plugins/floatingLinkEditor/utilities.js

@@ -0,0 +1,37 @@
+import { getBaseFields } from '../../drawer/baseFields';
+/**
+ * This function is run to enrich the basefields which every link has with potential, custom user-added fields.
+ */ export function transformExtraFields(customFieldSchema, config, i18n, enabledCollections, disabledCollections) {
+    const baseFields = getBaseFields(config, enabledCollections, disabledCollections);
+    const fields = typeof customFieldSchema === 'function' ? customFieldSchema({
+        config,
+        defaultFields: baseFields,
+        i18n
+    }) : baseFields;
+    // Wrap fields which are not part of the base schema in a group named 'fields' - otherwise they will be rendered but not saved
+    const extraFields = [];
+    for(let i = fields.length - 1; i >= 0; i--){
+        const field = fields[i];
+        if ('name' in field) {
+            if (!baseFields.find((baseField)=>!('name' in baseField) || baseField.name === field.name)) {
+                if (field.name !== 'fields' && field.type !== 'group') {
+                    extraFields.push(field);
+                    // Remove from fields from now, as they need to be part of the fields group below
+                    fields.splice(fields.indexOf(field), 1);
+                }
+            }
+        }
+    }
+    if (Array.isArray(customFieldSchema) || fields.length > 0) {
+        // find field with name 'fields' and add the extra fields to it
+        const fieldsField = fields.find((field)=>field.type === 'group' && field.name === 'fields');
+        if (!fieldsField) {
+            throw new Error('Could not find field with name "fields". This is required to add fields to the link field.');
+        }
+        fieldsField.fields = Array.isArray(fieldsField.fields) ? fieldsField.fields : [];
+        fieldsField.fields.push(...Array.isArray(customFieldSchema) ? customFieldSchema.concat(extraFields) : extraFields);
+    }
+    return fields;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/link/plugins/link/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/link/plugins/link/index.tsx"],"names":[],"mappings":"AAkBA,wBAAgB,UAAU,IAAI,IAAI,CAkEjC"}

package/dist/field/features/link/plugins/link/index.js

@@ -0,0 +1,59 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, PASTE_COMMAND } from 'lexical';
+import { useEffect } from 'react';
+import { validateUrl } from '../../../../lexical/utils/url';
+import { LinkNode, TOGGLE_LINK_COMMAND, toggleLink } from '../../nodes/LinkNode';
+export function LinkPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>{
+        if (!editor.hasNodes([
+            LinkNode
+        ])) {
+            throw new Error('LinkPlugin: LinkNode not registered on editor');
+        }
+        return mergeRegister(editor.registerCommand(TOGGLE_LINK_COMMAND, (payload)=>{
+            // validate
+            if (payload?.fields.linkType === 'custom') {
+                if (!(validateUrl === undefined || validateUrl(payload?.fields.url))) {
+                    return false;
+                }
+            }
+            toggleLink(payload);
+            return true;
+        }, COMMAND_PRIORITY_LOW), validateUrl !== undefined ? editor.registerCommand(PASTE_COMMAND, (event)=>{
+            const selection = $getSelection();
+            if (!$isRangeSelection(selection) || selection.isCollapsed() || !(event instanceof ClipboardEvent) || event.clipboardData == null) {
+                return false;
+            }
+            const clipboardText = event.clipboardData.getData('text');
+            if (!validateUrl(clipboardText)) {
+                return false;
+            }
+            // If we select nodes that are elements then avoid applying the link.
+            if (!selection.getNodes().some((node)=>$isElementNode(node))) {
+                const linkFields = {
+                    doc: null,
+                    linkType: 'custom',
+                    newTab: false,
+                    url: clipboardText
+                };
+                editor.dispatchCommand(TOGGLE_LINK_COMMAND, {
+                    fields: linkFields,
+                    text: null
+                });
+                event.preventDefault();
+                return true;
+            }
+            return false;
+        }, COMMAND_PRIORITY_LOW) : ()=>{
+        // Don't paste arbitrary text as a link when there's no validate function
+        });
+    }, [
+        editor
+    ]);
+    return null;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/link/populationPromise.d.ts

@@ -0,0 +1,5 @@
+import type { PopulationPromise } from '../types';
+import type { LinkFeatureServerProps } from './feature.server';
+import type { SerializedLinkNode } from './nodes/types';
+export declare const linkPopulationPromiseHOC: (props: LinkFeatureServerProps) => PopulationPromise<SerializedLinkNode>;
+//# sourceMappingURL=populationPromise.d.ts.map

package/dist/field/features/link/populationPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAKvD,eAAO,MAAM,wBAAwB,UAC5B,sBAAsB,KAC5B,kBAAkB,kBAAkB,CA+DtC,CAAA"}

package/dist/field/features/link/populationPromise.js

@@ -0,0 +1,46 @@
+import { populate } from '../../../populate/populate';
+import { recurseNestedFields } from '../../../populate/recurseNestedFields';
+export const linkPopulationPromiseHOC = (props)=>{
+    const linkPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
+        const promises = [];
+        if (node?.fields?.doc?.value && node?.fields?.doc?.relationTo) {
+            const collection = req.payload.collections[node?.fields?.doc?.relationTo];
+            if (collection) {
+                promises.push(populate({
+                    id: typeof node?.fields?.doc?.value === 'object' ? node?.fields?.doc?.value?.id : node?.fields?.doc?.value,
+                    collection,
+                    currentDepth,
+                    data: node?.fields?.doc,
+                    depth,
+                    field,
+                    key: 'value',
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+        }
+        if (Array.isArray(props.fields)) {
+            recurseNestedFields({
+                context,
+                currentDepth,
+                data: node.fields || {},
+                depth,
+                editorPopulationPromises,
+                fields: props.fields,
+                findMany,
+                flattenLocales,
+                overrideAccess,
+                populationPromises,
+                promises,
+                req,
+                showHiddenFields,
+                siblingDoc: node.fields || {}
+            });
+        }
+        return promises;
+    };
+    return linkPopulationPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saW5rL3BvcHVsYXRpb25Qcm9taXNlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUG9wdWxhdGlvblByb21pc2UgfSBmcm9tICcuLi90eXBlcydcbmltcG9ydCB0eXBlIHsgTGlua0ZlYXR1cmVTZXJ2ZXJQcm9wcyB9IGZyb20gJy4vZmVhdHVyZS5zZXJ2ZXInXG5pbXBvcnQgdHlwZSB7IFNlcmlhbGl6ZWRMaW5rTm9kZSB9IGZyb20gJy4vbm9kZXMvdHlwZXMnXG5cbmltcG9ydCB7IHBvcHVsYXRlIH0gZnJvbSAnLi4vLi4vLi4vcG9wdWxhdGUvcG9wdWxhdGUnXG5pbXBvcnQgeyByZWN1cnNlTmVzdGVkRmllbGRzIH0gZnJvbSAnLi4vLi4vLi4vcG9wdWxhdGUvcmVjdXJzZU5lc3RlZEZpZWxkcydcblxuZXhwb3J0IGNvbnN0IGxpbmtQb3B1bGF0aW9uUHJvbWlzZUhPQyA9IChcbiAgcHJvcHM6IExpbmtGZWF0dXJlU2VydmVyUHJvcHMsXG4pOiBQb3B1bGF0aW9uUHJvbWlzZTxTZXJpYWxpemVkTGlua05vZGU+ID0+IHtcbiAgY29uc3QgbGlua1BvcHVsYXRpb25Qcm9taXNlOiBQb3B1bGF0aW9uUHJvbWlzZTxTZXJpYWxpemVkTGlua05vZGU+ID0gKHtcbiAgICBjb250ZXh0LFxuICAgIGN1cnJlbnREZXB0aCxcbiAgICBkZXB0aCxcbiAgICBlZGl0b3JQb3B1bGF0aW9uUHJvbWlzZXMsXG4gICAgZmllbGQsXG4gICAgZmluZE1hbnksXG4gICAgZmxhdHRlbkxvY2FsZXMsXG4gICAgbm9kZSxcbiAgICBvdmVycmlkZUFjY2VzcyxcbiAgICBwb3B1bGF0aW9uUHJvbWlzZXMsXG4gICAgcmVxLFxuICAgIHNob3dIaWRkZW5GaWVsZHMsXG4gICAgc2libGluZ0RvYyxcbiAgfSkgPT4ge1xuICAgIGNvbnN0IHByb21pc2VzOiBQcm9taXNlPHZvaWQ+W10gPSBbXVxuXG4gICAgaWYgKG5vZGU/LmZpZWxkcz8uZG9jPy52YWx1ZSAmJiBub2RlPy5maWVsZHM/LmRvYz8ucmVsYXRpb25Ubykge1xuICAgICAgY29uc3QgY29sbGVjdGlvbiA9IHJlcS5wYXlsb2FkLmNvbGxlY3Rpb25zW25vZGU/LmZpZWxkcz8uZG9jPy5yZWxhdGlvblRvXVxuXG4gICAgICBpZiAoY29sbGVjdGlvbikge1xuICAgICAgICBwcm9taXNlcy5wdXNoKFxuICAgICAgICAgIHBvcHVsYXRlKHtcbiAgICAgICAgICAgIGlkOlxuICAgICAgICAgICAgICB0eXBlb2Ygbm9kZT8uZmllbGRzPy5kb2M/LnZhbHVlID09PSAnb2JqZWN0J1xuICAgICAgICAgICAgICAgID8gbm9kZT8uZmllbGRzPy5kb2M/LnZhbHVlPy5pZFxuICAgICAgICAgICAgICAgIDogbm9kZT8uZmllbGRzPy5kb2M/LnZhbHVlLFxuICAgICAgICAgICAgY29sbGVjdGlvbixcbiAgICAgICAgICAgIGN1cnJlbnREZXB0aCxcbiAgICAgICAgICAgIGRhdGE6IG5vZGU/LmZpZWxkcz8uZG9jLFxuICAgICAgICAgICAgZGVwdGgsXG4gICAgICAgICAgICBmaWVsZCxcbiAgICAgICAgICAgIGtleTogJ3ZhbHVlJyxcbiAgICAgICAgICAgIG92ZXJyaWRlQWNjZXNzLFxuICAgICAgICAgICAgcmVxLFxuICAgICAgICAgICAgc2hvd0hpZGRlbkZpZWxkcyxcbiAgICAgICAgICB9KSxcbiAgICAgICAgKVxuICAgICAgfVxuICAgIH1cbiAgICBpZiAoQXJyYXkuaXNBcnJheShwcm9wcy5maWVsZHMpKSB7XG4gICAgICByZWN1cnNlTmVzdGVkRmllbGRzKHtcbiAgICAgICAgY29udGV4dCxcbiAgICAgICAgY3VycmVudERlcHRoLFxuICAgICAgICBkYXRhOiBub2RlLmZpZWxkcyB8fCB7fSxcbiAgICAgICAgZGVwdGgsXG4gICAgICAgIGVkaXRvclBvcHVsYXRpb25Qcm9taXNlcyxcbiAgICAgICAgZmllbGRzOiBwcm9wcy5maWVsZHMsXG4gICAgICAgIGZpbmRNYW55LFxuICAgICAgICBmbGF0dGVuTG9jYWxlcyxcbiAgICAgICAgb3ZlcnJpZGVBY2Nlc3MsXG4gICAgICAgIHBvcHVsYXRpb25Qcm9taXNlcyxcbiAgICAgICAgcHJvbWlzZXMsXG4gICAgICAgIHJlcSxcbiAgICAgICAgc2hvd0hpZGRlbkZpZWxkcyxcbiAgICAgICAgc2libGluZ0RvYzogbm9kZS5maWVsZHMgfHwge30sXG4gICAgICB9KVxuICAgIH1cbiAgICByZXR1cm4gcHJvbWlzZXNcbiAgfVxuXG4gIHJldHVybiBsaW5rUG9wdWxhdGlvblByb21pc2Vcbn1cbiJdLCJuYW1lcyI6WyJwb3B1bGF0ZSIsInJlY3Vyc2VOZXN0ZWRGaWVsZHMiLCJsaW5rUG9wdWxhdGlvblByb21pc2VIT0MiLCJwcm9wcyIsImxpbmtQb3B1bGF0aW9uUHJvbWlzZSIsImNvbnRleHQiLCJjdXJyZW50RGVwdGgiLCJkZXB0aCIsImVkaXRvclBvcHVsYXRpb25Qcm9taXNlcyIsImZpZWxkIiwiZmluZE1hbnkiLCJmbGF0dGVuTG9jYWxlcyIsIm5vZGUiLCJvdmVycmlkZUFjY2VzcyIsInBvcHVsYXRpb25Qcm9taXNlcyIsInJlcSIsInNob3dIaWRkZW5GaWVsZHMiLCJzaWJsaW5nRG9jIiwicHJvbWlzZXMiLCJmaWVsZHMiLCJkb2MiLCJ2YWx1ZSIsInJlbGF0aW9uVG8iLCJjb2xsZWN0aW9uIiwicGF5bG9hZCIsImNvbGxlY3Rpb25zIiwicHVzaCIsImlkIiwiZGF0YSIsImtleSIsIkFycmF5IiwiaXNBcnJheSJdLCJtYXBwaW5ncyI6IkFBSUEsU0FBU0EsUUFBUSxRQUFRLDZCQUE0QjtBQUNyRCxTQUFTQyxtQkFBbUIsUUFBUSx3Q0FBdUM7QUFFM0UsT0FBTyxNQUFNQywyQkFBMkIsQ0FDdENDO0lBRUEsTUFBTUMsd0JBQStELENBQUMsRUFDcEVDLE9BQU8sRUFDUEMsWUFBWSxFQUNaQyxLQUFLLEVBQ0xDLHdCQUF3QixFQUN4QkMsS0FBSyxFQUNMQyxRQUFRLEVBQ1JDLGNBQWMsRUFDZEMsSUFBSSxFQUNKQyxjQUFjLEVBQ2RDLGtCQUFrQixFQUNsQkMsR0FBRyxFQUNIQyxnQkFBZ0IsRUFDaEJDLFVBQVUsRUFDWDtRQUNDLE1BQU1DLFdBQTRCLEVBQUU7UUFFcEMsSUFBSU4sTUFBTU8sUUFBUUMsS0FBS0MsU0FBU1QsTUFBTU8sUUFBUUMsS0FBS0UsWUFBWTtZQUM3RCxNQUFNQyxhQUFhUixJQUFJUyxPQUFPLENBQUNDLFdBQVcsQ0FBQ2IsTUFBTU8sUUFBUUMsS0FBS0UsV0FBVztZQUV6RSxJQUFJQyxZQUFZO2dCQUNkTCxTQUFTUSxJQUFJLENBQ1gxQixTQUFTO29CQUNQMkIsSUFDRSxPQUFPZixNQUFNTyxRQUFRQyxLQUFLQyxVQUFVLFdBQ2hDVCxNQUFNTyxRQUFRQyxLQUFLQyxPQUFPTSxLQUMxQmYsTUFBTU8sUUFBUUMsS0FBS0M7b0JBQ3pCRTtvQkFDQWpCO29CQUNBc0IsTUFBTWhCLE1BQU1PLFFBQVFDO29CQUNwQmI7b0JBQ0FFO29CQUNBb0IsS0FBSztvQkFDTGhCO29CQUNBRTtvQkFDQUM7Z0JBQ0Y7WUFFSjtRQUNGO1FBQ0EsSUFBSWMsTUFBTUMsT0FBTyxDQUFDNUIsTUFBTWdCLE1BQU0sR0FBRztZQUMvQmxCLG9CQUFvQjtnQkFDbEJJO2dCQUNBQztnQkFDQXNCLE1BQU1oQixLQUFLTyxNQUFNLElBQUksQ0FBQztnQkFDdEJaO2dCQUNBQztnQkFDQVcsUUFBUWhCLE1BQU1nQixNQUFNO2dCQUNwQlQ7Z0JBQ0FDO2dCQUNBRTtnQkFDQUM7Z0JBQ0FJO2dCQUNBSDtnQkFDQUM7Z0JBQ0FDLFlBQVlMLEtBQUtPLE1BQU0sSUFBSSxDQUFDO1lBQzlCO1FBQ0Y7UUFDQSxPQUFPRDtJQUNUO0lBRUEsT0FBT2Q7QUFDVCxFQUFDIn0=

package/dist/field/features/lists/checklist/feature.client.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const CheckListFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/lists/checklist/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/checklist/feature.client.tsx"],"names":[],"mappings":";AA8EA,eAAO,MAAM,+BAA+B,+BAAgD,CAAA"}