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

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

@@ -0,0 +1,293 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LinkEditor", {
+    enumerable: true,
+    get: function() {
+        return LinkEditor;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _translations = require("@payloadcms/translations");
+const _ui = require("@payloadcms/ui");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EditorConfigProvider = require("../../../../../lexical/config/client/EditorConfigProvider");
+const _getSelectedNode = require("../../../../../lexical/utils/getSelectedNode");
+const _setFloatingElemPositionForLinkEditor = require("../../../../../lexical/utils/setFloatingElemPositionForLinkEditor");
+const _drawer = require("../../../drawer");
+const _AutoLinkNode = require("../../../nodes/AutoLinkNode");
+const _LinkNode = require("../../../nodes/LinkNode");
+const _commands = require("./commands");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function LinkEditor({ anchorElem }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const editorRef = (0, _react.useRef)(null);
+    const [linkUrl, setLinkUrl] = (0, _react.useState)('');
+    const [linkLabel, setLinkLabel] = (0, _react.useState)('');
+    const { uuid } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const config = (0, _ui.useConfig)();
+    const { i18n, t } = (0, _ui.useTranslation)();
+    const [stateData, setStateData] = (0, _react.useState)(null);
+    const { closeModal, toggleModal } = (0, _modal.useModal)();
+    const editDepth = (0, _ui.useEditDepth)();
+    const [isLink, setIsLink] = (0, _react.useState)(false);
+    const [isAutoLink, setIsAutoLink] = (0, _react.useState)(false);
+    const drawerSlug = (0, _ui.formatDrawerSlug)({
+        slug: `lexical-rich-text-link-` + uuid,
+        depth: editDepth
+    });
+    const updateLinkEditor = (0, _react.useCallback)(()=>{
+        const selection = (0, _lexical.$getSelection)();
+        let selectedNodeDomRect = null;
+        // Handle the data displayed in the floating link editor & drawer when you click on a link node
+        if ((0, _lexical.$isRangeSelection)(selection)) {
+            const node = (0, _getSelectedNode.getSelectedNode)(selection);
+            selectedNodeDomRect = editor.getElementByKey(node.getKey())?.getBoundingClientRect();
+            const linkParent = (0, _utils.$findMatchingParent)(node, _LinkNode.$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: (0, _translations.getTranslation)(relatedField.labels.singular, i18n)
+                }).replace(/<[^>]*>?/g, '');
+                setLinkLabel(label);
+            }
+            setStateData(data);
+            setIsLink(true);
+            if ((0, _AutoLinkNode.$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;
+                (0, _setFloatingElemPositionForLinkEditor.setFloatingElemPositionForLinkEditor)(selectedNodeDomRect, editorElem, anchorElem);
+            }
+        } else if (activeElement == null || activeElement.className !== 'link-input') {
+            if (rootElement !== null) {
+                (0, _setFloatingElemPositionForLinkEditor.setFloatingElemPositionForLinkEditor)(null, editorElem, anchorElem);
+            }
+            setLinkUrl('');
+            setLinkLabel('');
+        }
+        return true;
+    }, [
+        anchorElem,
+        editor,
+        config,
+        t,
+        i18n
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerCommand(_commands.TOGGLE_LINK_WITH_MODAL_COMMAND, (payload)=>{
+            editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, payload);
+            // Now, open the modal
+            updateLinkEditor();
+            toggleModal(drawerSlug);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        updateLinkEditor,
+        toggleModal,
+        drawerSlug
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (!isLink && editorRef) {
+            editorRef.current.style.opacity = '0';
+            editorRef.current.style.transform = 'translate(-10000px, -10000px)';
+        }
+    }, [
+        isLink
+    ]);
+    (0, _react.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
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(({ editorState })=>{
+            editorState.read(()=>{
+                void updateLinkEditor();
+            });
+        }), editor.registerCommand(_lexical.SELECTION_CHANGE_COMMAND, ()=>{
+            void updateLinkEditor();
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_ESCAPE_COMMAND, ()=>{
+            if (isLink) {
+                setIsLink(false);
+                setIsAutoLink(false);
+                return true;
+            }
+            return false;
+        }, _lexical.COMMAND_PRIORITY_HIGH));
+    }, [
+        editor,
+        updateLinkEditor,
+        setIsLink,
+        isLink
+    ]);
+    (0, _react.useEffect)(()=>{
+        editor.getEditorState().read(()=>{
+            void updateLinkEditor();
+        });
+    }, [
+        editor,
+        updateLinkEditor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: "link-editor",
+        ref: editorRef
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: "link-input"
+    }, /*#__PURE__*/ _react.default.createElement("a", {
+        href: linkUrl,
+        rel: "noopener noreferrer",
+        target: "_blank"
+    }, linkLabel != null && linkLabel.length > 0 ? linkLabel : linkUrl), editor.isEditable() && /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("button", {
+        "aria-label": "Edit link",
+        className: "link-edit",
+        onClick: ()=>{
+            toggleModal(drawerSlug);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    }), !isAutoLink && /*#__PURE__*/ _react.default.createElement("button", {
+        "aria-label": "Remove link",
+        className: "link-trash",
+        onClick: ()=>{
+            editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, null);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    })))), /*#__PURE__*/ _react.default.createElement(_drawer.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 = (0, _lexical.$getSelection)();
+                if ((0, _lexical.$isRangeSelection)(selection)) {
+                    const parent = (0, _getSelectedNode.getSelectedNode)(selection).getParent();
+                    if ((0, _AutoLinkNode.$isAutoLinkNode)(parent)) {
+                        const linkNode = (0, _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(_LinkNode.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":["LinkEditor","anchorElem","editor","useLexicalComposerContext","editorRef","useRef","linkUrl","setLinkUrl","useState","linkLabel","setLinkLabel","uuid","useEditorConfigContext","config","useConfig","i18n","t","useTranslation","stateData","setStateData","closeModal","toggleModal","useModal","editDepth","useEditDepth","isLink","setIsLink","isAutoLink","setIsAutoLink","drawerSlug","formatDrawerSlug","slug","depth","updateLinkEditor","useCallback","selection","$getSelection","selectedNodeDomRect","$isRangeSelection","node","getSelectedNode","getElementByKey","getKey","getBoundingClientRect","linkParent","$findMatchingParent","$isLinkNode","data","fields","doc","undefined","linkType","newTab","url","getFields","text","getTextContent","relationTo","value","relatedField","collections","find","coll","label","getTranslation","labels","singular","replace","$isAutoLinkNode","editorElem","current","nativeSelection","window","getSelection","activeElement","document","rootElement","getRootElement","contains","anchorNode","getRangeAt","y","setFloatingElemPositionForLinkEditor","className","useEffect","mergeRegister","registerCommand","TOGGLE_LINK_WITH_MODAL_COMMAND","payload","dispatchCommand","TOGGLE_LINK_COMMAND","COMMAND_PRIORITY_LOW","style","opacity","transform","scrollerElem","parentElement","update","getEditorState","read","addEventListener","removeEventListener","registerUpdateListener","editorState","SELECTION_CHANGE_COMMAND","KEY_ESCAPE_COMMAND","COMMAND_PRIORITY_HIGH","React","Fragment","div","ref","a","href","rel","target","length","isEditable","button","aria-label","onClick","onMouseDown","event","preventDefault","tabIndex","type","LinkDrawer","handleModalSubmit","newLinkPayload","parent","getParent","linkNode","$createLinkNode"],"mappings":"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"}

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,64 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FloatingLinkEditorPlugin", {
+    enumerable: true,
+    get: function() {
+        return FloatingLinkEditorPlugin;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _LinkEditor = require("./LinkEditor");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const FloatingLinkEditorPlugin = (props)=>{
+    const { anchorElem = document.body } = props;
+    return /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.createElement(_LinkEditor.LinkEditor, {
+        anchorElem: anchorElem
+    }), anchorElem);
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saW5rL3BsdWdpbnMvZmxvYXRpbmdMaW5rRWRpdG9yL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgY3JlYXRlUG9ydGFsIH0gZnJvbSAncmVhY3QtZG9tJ1xuXG5pbXBvcnQgeyBMaW5rRWRpdG9yIH0gZnJvbSAnLi9MaW5rRWRpdG9yJ1xuaW1wb3J0ICcuL2luZGV4LnNjc3MnXG5cbmV4cG9ydCBjb25zdCBGbG9hdGluZ0xpbmtFZGl0b3JQbHVnaW46IFJlYWN0LkZDPHtcbiAgYW5jaG9yRWxlbTogSFRNTEVsZW1lbnRcbn0+ID0gKHByb3BzKSA9PiB7XG4gIGNvbnN0IHsgYW5jaG9yRWxlbSA9IGRvY3VtZW50LmJvZHkgfSA9IHByb3BzXG5cbiAgcmV0dXJuIGNyZWF0ZVBvcnRhbCg8TGlua0VkaXRvciBhbmNob3JFbGVtPXthbmNob3JFbGVtfSAvPiwgYW5jaG9yRWxlbSlcbn1cbiJdLCJuYW1lcyI6WyJGbG9hdGluZ0xpbmtFZGl0b3JQbHVnaW4iLCJwcm9wcyIsImFuY2hvckVsZW0iLCJkb2N1bWVudCIsImJvZHkiLCJjcmVhdGVQb3J0YWwiLCJMaW5rRWRpdG9yIl0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7K0JBT2FBOzs7ZUFBQUE7OzsrREFOVTswQkFDTTs0QkFFRjtRQUNwQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsTUFBTUEsMkJBRVIsQ0FBQ0M7SUFDSixNQUFNLEVBQUVDLGFBQWFDLFNBQVNDLElBQUksRUFBRSxHQUFHSDtJQUV2QyxxQkFBT0ksSUFBQUEsc0JBQVksZ0JBQUMscUJBQUNDLHNCQUFVO1FBQUNKLFlBQVlBO1FBQWdCQTtBQUM5RCJ9

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/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,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformExtraFields", {
+    enumerable: true,
+    get: function() {
+        return transformExtraFields;
+    }
+});
+const _baseFields = require("../../drawer/baseFields");
+function transformExtraFields(customFieldSchema, config, i18n, enabledCollections, disabledCollections) {
+    const baseFields = (0, _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"}