@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RelationshipFeature", {
+    enumerable: true,
+    get: function() {
+        return RelationshipFeature;
+    }
+});
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _Relationship = require("../../lexical/ui/icons/Relationship");
+const _afterReadPromise = require("./afterReadPromise");
+const _drawer = require("./drawer");
+require("./index.scss");
+const _RelationshipNode = require("./nodes/RelationshipNode");
+const _plugins = /*#__PURE__*/ _interop_require_default(require("./plugins"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const RelationshipFeature = ()=>{
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                nodes: [
+                    {
+                        afterReadPromises: [
+                            _afterReadPromise.relationshipAfterReadPromise
+                        ],
+                        node: _RelationshipNode.RelationshipNode,
+                        type: _RelationshipNode.RelationshipNode.getType()
+                    }
+                ],
+                plugins: [
+                    {
+                        Component: _plugins.default,
+                        position: 'normal'
+                    }
+                ],
+                props: null,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption('Relationship', {
+                                    Icon: _Relationship.RelationshipIcon,
+                                    keywords: [
+                                        'relationship',
+                                        'relation',
+                                        'rel'
+                                    ],
+                                    onSelect: ({ editor, queryString })=>{
+                                        // dispatch INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND
+                                        editor.dispatchCommand(_drawer.INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, {
+                                            replace: false
+                                        });
+                                    }
+                                })
+                            ],
+                            title: 'Basic'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'relationship'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Relationship/nodes/RelationshipNode.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, ElementFormatType, LexicalEditor, LexicalNode, NodeKey, Spread } from 'lexical';
+import { DecoratorBlockNode, type SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+export type RelationshipFields = {
+    data: null | unknown;
+    id: string;
+    relationTo: string;
+};
+export type SerializedRelationshipNode = Spread<{
+    fields: RelationshipFields;
+}, SerializedDecoratorBlockNode>;
+export declare class RelationshipNode extends DecoratorBlockNode {
+    __fields: RelationshipFields;
+    constructor({ fields, format, key, }: {
+        fields: RelationshipFields;
+        format?: ElementFormatType;
+        key?: NodeKey;
+    });
+    static clone(node: RelationshipNode): RelationshipNode;
+    static getType(): string;
+    static importDOM(): DOMConversionMap<HTMLDivElement> | null;
+    static importJSON(serializedNode: SerializedRelationshipNode): RelationshipNode;
+    static isInline(): false;
+    decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedRelationshipNode;
+    getFields(): RelationshipFields;
+    getId(): string;
+    getTextContent(): string;
+    setFields(fields: RelationshipFields): void;
+}
+export declare function $createRelationshipNode(fields: RelationshipFields): RelationshipNode;
+export declare function $isRelationshipNode(node: LexicalNode | RelationshipNode | null | undefined): node is RelationshipNode;
+//# sourceMappingURL=RelationshipNode.d.ts.map

package/dist/field/features/Relationship/nodes/RelationshipNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationshipNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Relationship/nodes/RelationshipNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,OAAO,EACP,MAAM,EACP,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,kBAAkB,EAClB,KAAK,4BAA4B,EAClC,MAAM,0CAA0C,CAAA;AAKjD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,IAAI,GAAG,OAAO,CAAA;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAC7C;IACE,MAAM,EAAE,kBAAkB,CAAA;CAC3B,EACD,4BAA4B,CAC7B,CAAA;AAiBD,qBAAa,gBAAiB,SAAQ,kBAAkB;IACtD,QAAQ,EAAE,kBAAkB,CAAA;gBAEhB,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,kBAAkB,CAAA;QAC1B,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB;IAQtD,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI;IAiB3D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,0BAA0B,GAAG,gBAAgB;IAM/E,MAAM,CAAC,QAAQ,IAAI,KAAK;IAGxB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAWlE,SAAS,IAAI,eAAe;IAU5B,UAAU,IAAI,0BAA0B;IASxC,SAAS,IAAI,kBAAkB;IAI/B,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;CAI5C;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,CAIpF;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,GAAG,gBAAgB,GAAG,IAAI,GAAG,SAAS,GACtD,IAAI,IAAI,gBAAgB,CAE1B"}

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

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

package/dist/field/features/Relationship/nodes/components/RelationshipComponent.d.ts

@@ -0,0 +1,14 @@
+import { type ElementFormatType } from 'lexical';
+import React from 'react';
+import type { RelationshipFields } from '../RelationshipNode';
+import './index.scss';
+type Props = {
+    children?: React.ReactNode;
+    className?: string;
+    fields: RelationshipFields;
+    format?: ElementFormatType;
+    nodeKey?: string;
+};
+export declare const RelationshipComponent: (props: Props) => React.ReactNode;
+export {};
+//# sourceMappingURL=RelationshipComponent.d.ts.map

package/dist/field/features/Relationship/nodes/components/RelationshipComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationshipComponent.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/Relationship/nodes/components/RelationshipComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAM/D,OAAO,KAA4C,MAAM,OAAO,CAAA;AAGhE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAK7D,OAAO,cAAc,CAAA;AAQrB,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAuGD,eAAO,MAAM,qBAAqB,UAAW,KAAK,KAAG,MAAM,SAM1D,CAAA"}

package/dist/field/features/Relationship/nodes/components/RelationshipComponent.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RelationshipComponent", {
+    enumerable: true,
+    get: function() {
+        return RelationshipComponent;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _useLexicalNodeSelection = require("@lexical/react/useLexicalNodeSelection");
+const _lexical = require("lexical");
+const _components = require("payload/components");
+const _elements = require("payload/components/elements");
+const _hooks = require("payload/components/hooks");
+const _utilities = require("payload/components/utilities");
+const _utilities1 = require("payload/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _EditorConfigProvider = require("../../../../lexical/config/EditorConfigProvider");
+const _drawer = require("../../drawer");
+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';
+const initialParams = {
+    depth: 0
+};
+const Component = (props)=>{
+    const { children, fields: { id, relationTo }, nodeKey } = props;
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [isSelected, setSelected, clearSelection] = (0, _useLexicalNodeSelection.useLexicalNodeSelection)(nodeKey);
+    const { field } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const { collections, routes: { api }, serverURL } = (0, _utilities.useConfig)();
+    const [relatedCollection, setRelatedCollection] = (0, _react.useState)(()=>collections.find((coll)=>coll.slug === relationTo));
+    const { i18n, t } = (0, _reacti18next.useTranslation)([
+        'fields',
+        'general'
+    ]);
+    const [cacheBust, dispatchCacheBust] = (0, _react.useReducer)((state)=>state + 1, 0);
+    const [{ data }, { setParams }] = (0, _hooks.usePayloadAPI)(`${serverURL}${api}/${relatedCollection.slug}/${id}`, {
+        initialParams
+    });
+    const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = (0, _elements.useDocumentDrawer)({
+        id: id,
+        collectionSlug: relatedCollection.slug
+    });
+    const removeRelationship = (0, _react.useCallback)(()=>{
+        editor.update(()=>{
+            (0, _lexical.$getNodeByKey)(nodeKey).remove();
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    const updateRelationship = _react.default.useCallback(({ doc })=>{
+        setParams({
+            ...initialParams,
+            cacheBust
+        });
+        closeDrawer();
+        dispatchCacheBust();
+    }, [
+        cacheBust,
+        setParams,
+        closeDrawer
+    ]);
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            baseClass,
+            isSelected && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        contentEditable: false
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__wrap`
+    }, /*#__PURE__*/ _react.default.createElement("p", {
+        className: `${baseClass}__label`
+    }, t('labelRelationship', {
+        label: (0, _utilities1.getTranslation)(relatedCollection.labels.singular, i18n)
+    })), /*#__PURE__*/ _react.default.createElement(DocumentDrawerToggler, {
+        className: `${baseClass}__doc-drawer-toggler`
+    }, /*#__PURE__*/ _react.default.createElement("p", {
+        className: `${baseClass}__title`
+    }, data[relatedCollection?.admin?.useAsTitle || 'id']))), /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__actions`
+    }, /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        disabled: field?.admin?.readOnly,
+        el: "div",
+        icon: "swap",
+        onClick: ()=>{
+            editor.dispatchCommand(_drawer.INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, {
+                replace: {
+                    nodeKey
+                }
+            });
+        },
+        round: true,
+        tooltip: t('swapRelationship')
+    }), /*#__PURE__*/ _react.default.createElement(_components.Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__removeButton`,
+        disabled: field?.admin?.readOnly,
+        icon: "x",
+        onClick: (e)=>{
+            e.preventDefault();
+            removeRelationship();
+        },
+        round: true,
+        tooltip: t('fields:removeRelationship')
+    })), id && /*#__PURE__*/ _react.default.createElement(DocumentDrawer, {
+        onSave: updateRelationship
+    }), children);
+};
+const RelationshipComponent = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, props, /*#__PURE__*/ _react.default.createElement(Component, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/Relationship/nodes/components/RelationshipComponent.tsx"],"sourcesContent":["import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection'\nimport { $getNodeByKey, type ElementFormatType } from 'lexical'\nimport { Button } from 'payload/components'\nimport { useDocumentDrawer } from 'payload/components/elements'\nimport { usePayloadAPI } from 'payload/components/hooks'\nimport { useConfig } from 'payload/components/utilities'\nimport { getTranslation } from 'payload/utilities'\nimport React, { useCallback, useReducer, useState } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { RelationshipFields } from '../RelationshipNode'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/EditorConfigProvider'\nimport { INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND } from '../../drawer'\nimport { EnabledRelationshipsCondition } from '../../utils/EnabledRelationshipsCondition'\nimport './index.scss'\n\nconst baseClass = 'lexical-relationship'\n\nconst initialParams = {\n  depth: 0,\n}\n\ntype Props = {\n  children?: React.ReactNode\n  className?: string\n  fields: RelationshipFields\n  format?: ElementFormatType\n  nodeKey?: string\n}\n\nconst Component: React.FC<Props> = (props) => {\n  const {\n    children,\n    fields: { id, relationTo },\n    nodeKey,\n  } = props\n\n  const [editor] = useLexicalComposerContext()\n  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey)\n  const { field } = useEditorConfigContext()\n  const {\n    collections,\n    routes: { api },\n    serverURL,\n  } = useConfig()\n\n  const [relatedCollection, setRelatedCollection] = useState(() =>\n    collections.find((coll) => coll.slug === relationTo),\n  )\n\n  const { i18n, t } = useTranslation(['fields', 'general'])\n  const [cacheBust, dispatchCacheBust] = useReducer((state) => state + 1, 0)\n  const [{ data }, { setParams }] = usePayloadAPI(\n    `${serverURL}${api}/${relatedCollection.slug}/${id}`,\n    { initialParams },\n  )\n\n  const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = useDocumentDrawer({\n    id: id,\n    collectionSlug: relatedCollection.slug,\n  })\n\n  const removeRelationship = useCallback(() => {\n    editor.update(() => {\n      $getNodeByKey(nodeKey).remove()\n    })\n  }, [editor, nodeKey])\n\n  const updateRelationship = React.useCallback(\n    ({ doc }) => {\n      setParams({\n        ...initialParams,\n        cacheBust, // do this to get the usePayloadAPI to re-fetch the data even though the URL string hasn't changed\n      })\n\n      closeDrawer()\n      dispatchCacheBust()\n    },\n    [cacheBust, setParams, closeDrawer],\n  )\n\n  return (\n    <div\n      className={[baseClass, isSelected && `${baseClass}--selected`].filter(Boolean).join(' ')}\n      contentEditable={false}\n    >\n      <div className={`${baseClass}__wrap`}>\n        <p className={`${baseClass}__label`}>\n          {t('labelRelationship', {\n            label: getTranslation(relatedCollection.labels.singular, i18n),\n          })}\n        </p>\n        <DocumentDrawerToggler className={`${baseClass}__doc-drawer-toggler`}>\n          <p className={`${baseClass}__title`}>\n            {data[relatedCollection?.admin?.useAsTitle || 'id']}\n          </p>\n        </DocumentDrawerToggler>\n      </div>\n      <div className={`${baseClass}__actions`}>\n        <Button\n          buttonStyle=\"icon-label\"\n          disabled={field?.admin?.readOnly}\n          el=\"div\"\n          icon=\"swap\"\n          onClick={() => {\n            editor.dispatchCommand(INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, {\n              replace: { nodeKey },\n            })\n          }}\n          round\n          tooltip={t('swapRelationship')}\n        />\n        <Button\n          buttonStyle=\"icon-label\"\n          className={`${baseClass}__removeButton`}\n          disabled={field?.admin?.readOnly}\n          icon=\"x\"\n          onClick={(e) => {\n            e.preventDefault()\n            removeRelationship()\n          }}\n          round\n          tooltip={t('fields:removeRelationship')}\n        />\n      </div>\n      {id && <DocumentDrawer onSave={updateRelationship} />}\n      {children}\n    </div>\n  )\n}\n\nexport const RelationshipComponent = (props: Props): React.ReactNode => {\n  return (\n    <EnabledRelationshipsCondition {...props}>\n      <Component {...props} />\n    </EnabledRelationshipsCondition>\n  )\n}\n"],"names":["RelationshipComponent","baseClass","initialParams","depth","Component","props","children","fields","id","relationTo","nodeKey","editor","useLexicalComposerContext","isSelected","setSelected","clearSelection","useLexicalNodeSelection","field","useEditorConfigContext","collections","routes","api","serverURL","useConfig","relatedCollection","setRelatedCollection","useState","find","coll","slug","i18n","t","useTranslation","cacheBust","dispatchCacheBust","useReducer","state","data","setParams","usePayloadAPI","DocumentDrawer","DocumentDrawerToggler","closeDrawer","useDocumentDrawer","collectionSlug","removeRelationship","useCallback","update","$getNodeByKey","remove","updateRelationship","React","doc","div","className","filter","Boolean","join","contentEditable","p","label","getTranslation","labels","singular","admin","useAsTitle","Button","buttonStyle","disabled","readOnly","el","icon","onClick","dispatchCommand","INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND","replace","round","tooltip","e","preventDefault","onSave","EnabledRelationshipsCondition"],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { type LexicalCommand } from 'lexical';
+import type { RelationshipFields } from '../nodes/RelationshipNode';
+export declare const INSERT_RELATIONSHIP_COMMAND: LexicalCommand<RelationshipFields>;
+export default function RelationshipPlugin(): JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Relationship/plugins/index.tsx"],"names":[],"mappings":";AAEA,OAAO,EAA2B,KAAK,cAAc,EAAiB,MAAM,SAAS,CAAA;AAKrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAKnE,eAAO,MAAM,2BAA2B,EAAE,cAAc,CAAC,kBAAkB,CAE1E,CAAA;AAED,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAsB/D"}

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

@@ -0,0 +1,88 @@
+"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_COMMAND: function() {
+        return INSERT_RELATIONSHIP_COMMAND;
+    },
+    default: function() {
+        return RelationshipPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _utilities = require("payload/components/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _drawer = require("../drawer");
+const _RelationshipNode = require("../nodes/RelationshipNode");
+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 INSERT_RELATIONSHIP_COMMAND = (0, _lexical.createCommand)('INSERT_RELATIONSHIP_COMMAND');
+function RelationshipPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { collections } = (0, _utilities.useConfig)();
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _RelationshipNode.RelationshipNode
+        ])) {
+            throw new Error('RelationshipPlugin: RelationshipNode not registered on editor');
+        }
+        return editor.registerCommand(INSERT_RELATIONSHIP_COMMAND, (payload)=>{
+            const relationshipNode = (0, _RelationshipNode.$createRelationshipNode)(payload);
+            (0, _utils.$insertNodeToNearestRoot)(relationshipNode);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_drawer.RelationshipDrawer, {
+        enabledCollectionSlugs: collections.map(({ slug })=>slug)
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Relationship/utils/EnabledRelationshipsCondition.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare const EnabledRelationshipsCondition: React.FC<any>;
+//# sourceMappingURL=EnabledRelationshipsCondition.d.ts.map

package/dist/field/features/Relationship/utils/EnabledRelationshipsCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnabledRelationshipsCondition.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Relationship/utils/EnabledRelationshipsCondition.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAkB9B,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAYvD,CAAA"}