@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,61 @@
+"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 = {};
+    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 = ({ anchorElem = document.body, fields = [] })=>{
+    return /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.createElement(_LinkEditor.LinkEditor, {
+        anchorElem: anchorElem,
+        fields: fields
+    }), anchorElem);
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9MaW5rL3BsdWdpbnMvZmxvYXRpbmdMaW5rRWRpdG9yL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IGNyZWF0ZVBvcnRhbCB9IGZyb20gJ3JlYWN0LWRvbSdcblxuaW1wb3J0IHR5cGUgeyBMaW5rRmVhdHVyZVByb3BzIH0gZnJvbSAnLi4vLi4nXG5cbmltcG9ydCB7IExpbmtFZGl0b3IgfSBmcm9tICcuL0xpbmtFZGl0b3InXG5pbXBvcnQgJy4vaW5kZXguc2NzcydcblxuZXhwb3J0IGNvbnN0IEZsb2F0aW5nTGlua0VkaXRvclBsdWdpbjogUmVhY3QuRkM8XG4gIHtcbiAgICBhbmNob3JFbGVtPzogSFRNTEVsZW1lbnRcbiAgfSAmIExpbmtGZWF0dXJlUHJvcHNcbj4gPSAoeyBhbmNob3JFbGVtID0gZG9jdW1lbnQuYm9keSwgZmllbGRzID0gW10gfSkgPT4ge1xuICByZXR1cm4gY3JlYXRlUG9ydGFsKDxMaW5rRWRpdG9yIGFuY2hvckVsZW09e2FuY2hvckVsZW19IGZpZWxkcz17ZmllbGRzfSAvPiwgYW5jaG9yRWxlbSlcbn1cbiJdLCJuYW1lcyI6WyJGbG9hdGluZ0xpbmtFZGl0b3JQbHVnaW4iLCJhbmNob3JFbGVtIiwiZG9jdW1lbnQiLCJib2R5IiwiZmllbGRzIiwiY3JlYXRlUG9ydGFsIiwiTGlua0VkaXRvciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFRYUE7OztlQUFBQTs7OytEQVJVOzBCQUNNOzRCQUlGO1FBQ3BCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsTUFBTUEsMkJBSVQsQ0FBQyxFQUFFQyxhQUFhQyxTQUFTQyxJQUFJLEVBQUVDLFNBQVMsRUFBRSxFQUFFO0lBQzlDLHFCQUFPQyxJQUFBQSxzQkFBWSxnQkFBQyxxQkFBQ0Msc0JBQVU7UUFBQ0wsWUFBWUE7UUFBWUcsUUFBUUE7UUFBWUg7QUFDOUUifQ==

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

@@ -0,0 +1,13 @@
+import type { LinkFields } from '../../nodes/LinkNode';
+/**
+ * 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,sBAAsB,CAAA;AAEtD;;;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 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,12 @@
+import type { i18n } from 'i18next';
+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): 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,SAAS,CAAA;AACnC,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,GACT,KAAK,EAAE,CAwCT"}

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

@@ -0,0 +1,44 @@
+"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) {
+    const baseFields = (0, _baseFields.getBaseFields)(config);
+    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 = [];
+    fields.forEach((field)=>{
+        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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9MaW5rL3BsdWdpbnMvZmxvYXRpbmdMaW5rRWRpdG9yL3V0aWxpdGllcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IGkxOG4gfSBmcm9tICdpMThuZXh0J1xuaW1wb3J0IHR5cGUgeyBTYW5pdGl6ZWRDb25maWcgfSBmcm9tICdwYXlsb2FkL2NvbmZpZydcbmltcG9ydCB0eXBlIHsgRmllbGQsIEdyb3VwRmllbGQgfSBmcm9tICdwYXlsb2FkL3R5cGVzJ1xuXG5pbXBvcnQgeyBnZXRCYXNlRmllbGRzIH0gZnJvbSAnLi4vLi4vZHJhd2VyL2Jhc2VGaWVsZHMnXG5cbi8qKlxuICogVGhpcyBmdW5jdGlvbiBpcyBydW4gdG8gZW5yaWNoIHRoZSBiYXNlZmllbGRzIHdoaWNoIGV2ZXJ5IGxpbmsgaGFzIHdpdGggcG90ZW50aWFsLCBjdXN0b20gdXNlci1hZGRlZCBmaWVsZHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0cmFuc2Zvcm1FeHRyYUZpZWxkcyhcbiAgY3VzdG9tRmllbGRTY2hlbWE6XG4gICAgfCAoKGFyZ3M6IHsgY29uZmlnOiBTYW5pdGl6ZWRDb25maWc7IGRlZmF1bHRGaWVsZHM6IEZpZWxkW107IGkxOG46IGkxOG4gfSkgPT4gRmllbGRbXSlcbiAgICB8IEZpZWxkW10sXG4gIGNvbmZpZzogU2FuaXRpemVkQ29uZmlnLFxuICBpMThuOiBpMThuLFxuKTogRmllbGRbXSB7XG4gIGNvbnN0IGJhc2VGaWVsZHM6IEZpZWxkW10gPSBnZXRCYXNlRmllbGRzKGNvbmZpZylcblxuICBjb25zdCBmaWVsZHMgPVxuICAgIHR5cGVvZiBjdXN0b21GaWVsZFNjaGVtYSA9PT0gJ2Z1bmN0aW9uJ1xuICAgICAgPyBjdXN0b21GaWVsZFNjaGVtYSh7IGNvbmZpZywgZGVmYXVsdEZpZWxkczogYmFzZUZpZWxkcywgaTE4biB9KVxuICAgICAgOiBiYXNlRmllbGRzXG5cbiAgLy8gV3JhcCBmaWVsZHMgd2hpY2ggYXJlIG5vdCBwYXJ0IG9mIHRoZSBiYXNlIHNjaGVtYSBpbiBhIGdyb3VwIG5hbWVkICdmaWVsZHMnIC0gb3RoZXJ3aXNlIHRoZXkgd2lsbCBiZSByZW5kZXJlZCBidXQgbm90IHNhdmVkXG4gIGNvbnN0IGV4dHJhRmllbGRzID0gW11cbiAgZmllbGRzLmZvckVhY2goKGZpZWxkKSA9PiB7XG4gICAgaWYgKCduYW1lJyBpbiBmaWVsZCkge1xuICAgICAgaWYgKFxuICAgICAgICAhYmFzZUZpZWxkcy5maW5kKChiYXNlRmllbGQpID0+ICEoJ25hbWUnIGluIGJhc2VGaWVsZCkgfHwgYmFzZUZpZWxkLm5hbWUgPT09IGZpZWxkLm5hbWUpXG4gICAgICApIHtcbiAgICAgICAgaWYgKGZpZWxkLm5hbWUgIT09ICdmaWVsZHMnICYmIGZpZWxkLnR5cGUgIT09ICdncm91cCcpIHtcbiAgICAgICAgICBleHRyYUZpZWxkcy5wdXNoKGZpZWxkKVxuICAgICAgICAgIC8vIFJlbW92ZSBmcm9tIGZpZWxkcyBmcm9tIG5vdywgYXMgdGhleSBuZWVkIHRvIGJlIHBhcnQgb2YgdGhlIGZpZWxkcyBncm91cCBiZWxvd1xuICAgICAgICAgIGZpZWxkcy5zcGxpY2UoZmllbGRzLmluZGV4T2YoZmllbGQpLCAxKVxuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9KVxuXG4gIGlmIChBcnJheS5pc0FycmF5KGN1c3RvbUZpZWxkU2NoZW1hKSB8fCBmaWVsZHMubGVuZ3RoID4gMCkge1xuICAgIC8vIGZpbmQgZmllbGQgd2l0aCBuYW1lICdmaWVsZHMnIGFuZCBhZGQgdGhlIGV4dHJhIGZpZWxkcyB0byBpdFxuICAgIGNvbnN0IGZpZWxkc0ZpZWxkOiBHcm91cEZpZWxkID0gZmllbGRzLmZpbmQoXG4gICAgICAoZmllbGQpID0+IGZpZWxkLnR5cGUgPT09ICdncm91cCcgJiYgZmllbGQubmFtZSA9PT0gJ2ZpZWxkcycsXG4gICAgKSBhcyBHcm91cEZpZWxkXG4gICAgaWYgKCFmaWVsZHNGaWVsZCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICAnQ291bGQgbm90IGZpbmQgZmllbGQgd2l0aCBuYW1lIFwiZmllbGRzXCIuIFRoaXMgaXMgcmVxdWlyZWQgdG8gYWRkIGZpZWxkcyB0byB0aGUgbGluayBmaWVsZC4nLFxuICAgICAgKVxuICAgIH1cbiAgICBmaWVsZHNGaWVsZC5maWVsZHMgPSBBcnJheS5pc0FycmF5KGZpZWxkc0ZpZWxkLmZpZWxkcykgPyBmaWVsZHNGaWVsZC5maWVsZHMgOiBbXVxuICAgIGZpZWxkc0ZpZWxkLmZpZWxkcy5wdXNoKFxuICAgICAgLi4uKEFycmF5LmlzQXJyYXkoY3VzdG9tRmllbGRTY2hlbWEpID8gY3VzdG9tRmllbGRTY2hlbWEuY29uY2F0KGV4dHJhRmllbGRzKSA6IGV4dHJhRmllbGRzKSxcbiAgICApXG4gIH1cbiAgcmV0dXJuIGZpZWxkc1xufVxuIl0sIm5hbWVzIjpbInRyYW5zZm9ybUV4dHJhRmllbGRzIiwiY3VzdG9tRmllbGRTY2hlbWEiLCJjb25maWciLCJpMThuIiwiYmFzZUZpZWxkcyIsImdldEJhc2VGaWVsZHMiLCJmaWVsZHMiLCJkZWZhdWx0RmllbGRzIiwiZXh0cmFGaWVsZHMiLCJmb3JFYWNoIiwiZmllbGQiLCJmaW5kIiwiYmFzZUZpZWxkIiwibmFtZSIsInR5cGUiLCJwdXNoIiwic3BsaWNlIiwiaW5kZXhPZiIsIkFycmF5IiwiaXNBcnJheSIsImxlbmd0aCIsImZpZWxkc0ZpZWxkIiwiRXJyb3IiLCJjb25jYXQiXSwibWFwcGluZ3MiOiI7Ozs7K0JBU2dCQTs7O2VBQUFBOzs7NEJBTGM7QUFLdkIsU0FBU0EscUJBQ2RDLGlCQUVXLEVBQ1hDLE1BQXVCLEVBQ3ZCQyxJQUFVO0lBRVYsTUFBTUMsYUFBc0JDLElBQUFBLHlCQUFhLEVBQUNIO0lBRTFDLE1BQU1JLFNBQ0osT0FBT0wsc0JBQXNCLGFBQ3pCQSxrQkFBa0I7UUFBRUM7UUFBUUssZUFBZUg7UUFBWUQ7SUFBSyxLQUM1REM7SUFFTiw4SEFBOEg7SUFDOUgsTUFBTUksY0FBYyxFQUFFO0lBQ3RCRixPQUFPRyxPQUFPLENBQUMsQ0FBQ0M7UUFDZCxJQUFJLFVBQVVBLE9BQU87WUFDbkIsSUFDRSxDQUFDTixXQUFXTyxJQUFJLENBQUMsQ0FBQ0MsWUFBYyxDQUFFLENBQUEsVUFBVUEsU0FBUSxLQUFNQSxVQUFVQyxJQUFJLEtBQUtILE1BQU1HLElBQUksR0FDdkY7Z0JBQ0EsSUFBSUgsTUFBTUcsSUFBSSxLQUFLLFlBQVlILE1BQU1JLElBQUksS0FBSyxTQUFTO29CQUNyRE4sWUFBWU8sSUFBSSxDQUFDTDtvQkFDakIsaUZBQWlGO29CQUNqRkosT0FBT1UsTUFBTSxDQUFDVixPQUFPVyxPQUFPLENBQUNQLFFBQVE7Z0JBQ3ZDO1lBQ0Y7UUFDRjtJQUNGO0lBRUEsSUFBSVEsTUFBTUMsT0FBTyxDQUFDbEIsc0JBQXNCSyxPQUFPYyxNQUFNLEdBQUcsR0FBRztRQUN6RCwrREFBK0Q7UUFDL0QsTUFBTUMsY0FBMEJmLE9BQU9LLElBQUksQ0FDekMsQ0FBQ0QsUUFBVUEsTUFBTUksSUFBSSxLQUFLLFdBQVdKLE1BQU1HLElBQUksS0FBSztRQUV0RCxJQUFJLENBQUNRLGFBQWE7WUFDaEIsTUFBTSxJQUFJQyxNQUNSO1FBRUo7UUFDQUQsWUFBWWYsTUFBTSxHQUFHWSxNQUFNQyxPQUFPLENBQUNFLFlBQVlmLE1BQU0sSUFBSWUsWUFBWWYsTUFBTSxHQUFHLEVBQUU7UUFDaEZlLFlBQVlmLE1BQU0sQ0FBQ1MsSUFBSSxJQUNqQkcsTUFBTUMsT0FBTyxDQUFDbEIscUJBQXFCQSxrQkFBa0JzQixNQUFNLENBQUNmLGVBQWVBO0lBRW5GO0lBQ0EsT0FBT0Y7QUFDVCJ9

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

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+export declare function LinkPlugin(): null;
+//# sourceMappingURL=index.d.ts.map

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":"AAAA;;;;;;GAMG;AAkBH,wBAAgB,UAAU,IAAI,IAAI,CAkEjC"}

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

@@ -0,0 +1,74 @@
+/**
+ * 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
+});
+Object.defineProperty(exports, "LinkPlugin", {
+    enumerable: true,
+    get: function() {
+        return LinkPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = require("react");
+const _url = require("../../../../lexical/utils/url");
+const _LinkNode = require("../../nodes/LinkNode");
+function LinkPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _LinkNode.LinkNode
+        ])) {
+            throw new Error('LinkPlugin: LinkNode not registered on editor');
+        }
+        return (0, _utils.mergeRegister)(editor.registerCommand(_LinkNode.TOGGLE_LINK_COMMAND, (payload)=>{
+            // validate
+            if (payload?.fields.linkType === 'custom') {
+                if (!(_url.validateUrl === undefined || (0, _url.validateUrl)(payload?.fields.url))) {
+                    return false;
+                }
+            }
+            (0, _LinkNode.toggleLink)(payload);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), _url.validateUrl !== undefined ? editor.registerCommand(_lexical.PASTE_COMMAND, (event)=>{
+            const selection = (0, _lexical.$getSelection)();
+            if (!(0, _lexical.$isRangeSelection)(selection) || selection.isCollapsed() || !(event instanceof ClipboardEvent) || event.clipboardData == null) {
+                return false;
+            }
+            const clipboardText = event.clipboardData.getData('text');
+            if (!(0, _url.validateUrl)(clipboardText)) {
+                return false;
+            }
+            // If we select nodes that are elements then avoid applying the link.
+            if (!selection.getNodes().some((node)=>(0, _lexical.$isElementNode)(node))) {
+                const linkFields = {
+                    doc: null,
+                    linkType: 'custom',
+                    newTab: false,
+                    url: clipboardText
+                };
+                editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, {
+                    fields: linkFields,
+                    text: null
+                });
+                event.preventDefault();
+                return true;
+            }
+            return false;
+        }, _lexical.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/Paragraph/index.d.ts

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

package/dist/field/features/Paragraph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Paragraph/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAM/C,eAAO,MAAM,gBAAgB,QAAO,eAmDnC,CAAA"}

package/dist/field/features/Paragraph/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ParagraphFeature", {
+    enumerable: true,
+    get: function() {
+        return ParagraphFeature;
+    }
+});
+const _selection = require("@lexical/selection");
+const _lexical = require("lexical");
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _Text = require("../../lexical/ui/icons/Text");
+const _floatingSelectToolbarTextDropdownSection = require("../common/floatingSelectToolbarTextDropdownSection");
+const ParagraphFeature = ()=>{
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                floatingSelectToolbar: {
+                    sections: [
+                        (0, _floatingSelectToolbarTextDropdownSection.TextDropdownSectionWithEntries)([
+                            {
+                                ChildComponent: _Text.TextIcon,
+                                isActive: ({ editor, selection })=>false,
+                                key: 'normal-text',
+                                label: 'Normal Text',
+                                onClick: ({ editor })=>{
+                                    editor.update(()=>{
+                                        const selection = (0, _lexical.$getSelection)();
+                                        if ((0, _lexical.$isRangeSelection)(selection)) {
+                                            (0, _selection.$setBlocksType)(selection, ()=>(0, _lexical.$createParagraphNode)());
+                                        }
+                                    });
+                                },
+                                order: 1
+                            }
+                        ])
+                    ]
+                },
+                props: null,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption('Paragraph', {
+                                    Icon: _Text.TextIcon,
+                                    keywords: [
+                                        'normal',
+                                        'paragraph',
+                                        'p',
+                                        'text'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.update(()=>{
+                                            const selection = (0, _lexical.$getSelection)();
+                                            if ((0, _lexical.$isRangeSelection)(selection)) {
+                                                (0, _selection.$setBlocksType)(selection, ()=>(0, _lexical.$createParagraphNode)());
+                                            }
+                                        });
+                                    }
+                                })
+                            ],
+                            title: 'Basic'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'paragraph'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Relationship/afterReadPromise.d.ts

@@ -0,0 +1,4 @@
+import type { AfterReadPromise } from '../types';
+import type { SerializedRelationshipNode } from './nodes/RelationshipNode';
+export declare const relationshipAfterReadPromise: AfterReadPromise<SerializedRelationshipNode>;
+//# sourceMappingURL=afterReadPromise.d.ts.map

package/dist/field/features/Relationship/afterReadPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterReadPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Relationship/afterReadPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAA;AAI1E,eAAO,MAAM,4BAA4B,EAAE,gBAAgB,CAAC,0BAA0B,CAiCrF,CAAA"}

package/dist/field/features/Relationship/afterReadPromise.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "relationshipAfterReadPromise", {
+    enumerable: true,
+    get: function() {
+        return relationshipAfterReadPromise;
+    }
+});
+const _populate = require("../../../populate/populate");
+const relationshipAfterReadPromise = ({ currentDepth, depth, field, node, overrideAccess, req, showHiddenFields })=>{
+    const promises = [];
+    if (node?.fields?.id) {
+        const collection = req.payload.collections[node?.fields?.relationTo];
+        if (collection) {
+            promises.push((0, _populate.populate)({
+                id: node?.fields?.id,
+                collection,
+                currentDepth,
+                data: node.fields,
+                depth,
+                field,
+                key: 'data',
+                overrideAccess,
+                req,
+                showHiddenFields
+            }));
+        }
+    }
+    return promises;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Relationship/drawer/index.d.ts

@@ -0,0 +1,14 @@
+import { type LexicalCommand } from 'lexical';
+import React from 'react';
+import './index.scss';
+export declare const INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND: LexicalCommand<{
+    replace: {
+        nodeKey: string;
+    } | false;
+}>;
+type Props = {
+    enabledCollectionSlugs: string[];
+};
+export declare const RelationshipDrawer: (props: Props) => React.ReactNode;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Relationship/drawer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Relationship/drawer/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,cAAc,EAGpB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAA2C,MAAM,OAAO,CAAA;AAK/D,OAAO,cAAc,CAAA;AAIrB,eAAO,MAAM,uCAAuC,EAAE,cAAc,CAAC;IACnE,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAA4D,CAAA;AA6B7D,KAAK,KAAK,GAAG;IACX,sBAAsB,EAAE,MAAM,EAAE,CAAA;CACjC,CAAA;AAkDD,eAAO,MAAM,kBAAkB,UAAW,KAAK,KAAG,MAAM,SAMvD,CAAA"}

package/dist/field/features/Relationship/drawer/index.js

@@ -0,0 +1,135 @@
+"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, {
+    INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND: function() {
+        return INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND;
+    },
+    RelationshipDrawer: function() {
+        return RelationshipDrawer;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _elements = require("payload/components/elements");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _RelationshipNode = require("../nodes/RelationshipNode");
+const _plugins = require("../plugins");
+const _EnabledRelationshipsCondition = require("../utils/EnabledRelationshipsCondition");
+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 = {};
+    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 baseClass = 'lexical-relationship-drawer';
+const INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND = (0, _lexical.createCommand)('INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND');
+const insertRelationship = ({ id, editor, relationTo, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(_plugins.INSERT_RELATIONSHIP_COMMAND, {
+            id,
+            data: null,
+            relationTo
+        });
+    } else {
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(replaceNodeKey);
+            if (node) {
+                node.replace((0, _RelationshipNode.$createRelationshipNode)({
+                    id,
+                    data: null,
+                    relationTo
+                }));
+            }
+        });
+    }
+};
+const RelationshipDrawerComponent = ({ enabledCollectionSlugs })=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [selectedCollectionSlug, setSelectedCollectionSlug] = (0, _react.useState)(()=>enabledCollectionSlugs[0]);
+    const [replaceNodeKey, setReplaceNodeKey] = (0, _react.useState)(null);
+    const [ListDrawer, ListDrawerToggler, { closeDrawer, isDrawerOpen, openDrawer }] = (0, _elements.useListDrawer)({
+        collectionSlugs: enabledCollectionSlugs,
+        selectedCollection: selectedCollectionSlug
+    });
+    (0, _react.useEffect)(()=>{
+        return editor.registerCommand(INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openDrawer();
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        openDrawer
+    ]);
+    const onSelect = (0, _react.useCallback)(({ collectionConfig, docID })=>{
+        insertRelationship({
+            id: docID,
+            editor,
+            relationTo: collectionConfig.slug,
+            replaceNodeKey
+        });
+        closeDrawer();
+    }, [
+        editor,
+        closeDrawer,
+        replaceNodeKey
+    ]);
+    (0, _react.useEffect)(()=>{
+        // always reset back to first option
+        // TODO: this is not working, see the ListDrawer component
+        setSelectedCollectionSlug(enabledCollectionSlugs[0]);
+    }, [
+        isDrawerOpen,
+        enabledCollectionSlugs
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(ListDrawer, {
+        onSelect: onSelect
+    });
+};
+const RelationshipDrawer = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, props, /*#__PURE__*/ _react.default.createElement(RelationshipDrawerComponent, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Relationship/index.d.ts

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

package/dist/field/features/Relationship/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Relationship/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAM/C,OAAO,cAAc,CAAA;AAIrB,eAAO,MAAM,mBAAmB,QAAO,eAyCtC,CAAA"}