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

package/dist/field/features/paragraph/feature.client.d.ts

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

package/dist/field/features/paragraph/feature.client.d.ts.map

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

package/dist/field/features/paragraph/feature.client.js

@@ -0,0 +1,63 @@
+'use client';
+import { $setBlocksType } from '@lexical/selection';
+import { $createParagraphNode, $getSelection } from 'lexical';
+import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types';
+import { TextIcon } from '../../lexical/ui/icons/Text';
+import { TextDropdownSectionWithEntries } from '../common/floatingSelectToolbarTextDropdownSection';
+import { createClientComponent } from '../createClientComponent';
+const ParagraphFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                floatingSelectToolbar: {
+                    sections: [
+                        TextDropdownSectionWithEntries([
+                            {
+                                ChildComponent: TextIcon,
+                                isActive: ()=>false,
+                                key: 'normal-text',
+                                label: 'Normal Text',
+                                onClick: ({ editor })=>{
+                                    editor.update(()=>{
+                                        const selection = $getSelection();
+                                        $setBlocksType(selection, ()=>$createParagraphNode());
+                                    });
+                                },
+                                order: 1
+                            }
+                        ])
+                    ]
+                },
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Basic',
+                            key: 'basic',
+                            options: [
+                                new SlashMenuOption('paragraph', {
+                                    Icon: TextIcon,
+                                    displayName: 'Paragraph',
+                                    keywords: [
+                                        'normal',
+                                        'paragraph',
+                                        'p',
+                                        'text'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.update(()=>{
+                                            const selection = $getSelection();
+                                            $setBlocksType(selection, ()=>$createParagraphNode());
+                                        });
+                                    }
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+export const ParagraphFeatureClientComponent = createClientComponent(ParagraphFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/paragraph/feature.server.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProviderProviderServer } from '../types';
+export declare const ParagraphFeature: FeatureProviderProviderServer<undefined, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/paragraph/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/paragraph/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAI7D,eAAO,MAAM,gBAAgB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CAYhF,CAAA"}

package/dist/field/features/paragraph/feature.server.js

@@ -0,0 +1,16 @@
+import { ParagraphFeatureClientComponent } from './feature.client';
+export const ParagraphFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: ParagraphFeatureClientComponent,
+                clientFeatureProps: null,
+                serverFeatureProps: props
+            };
+        },
+        key: 'paragraph',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9wYXJhZ3JhcGgvZmVhdHVyZS5zZXJ2ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGZWF0dXJlUHJvdmlkZXJQcm92aWRlclNlcnZlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBQYXJhZ3JhcGhGZWF0dXJlQ2xpZW50Q29tcG9uZW50IH0gZnJvbSAnLi9mZWF0dXJlLmNsaWVudCdcblxuZXhwb3J0IGNvbnN0IFBhcmFncmFwaEZlYXR1cmU6IEZlYXR1cmVQcm92aWRlclByb3ZpZGVyU2VydmVyPHVuZGVmaW5lZCwgdW5kZWZpbmVkPiA9IChwcm9wcykgPT4ge1xuICByZXR1cm4ge1xuICAgIGZlYXR1cmU6ICgpID0+IHtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIENsaWVudENvbXBvbmVudDogUGFyYWdyYXBoRmVhdHVyZUNsaWVudENvbXBvbmVudCxcbiAgICAgICAgY2xpZW50RmVhdHVyZVByb3BzOiBudWxsLFxuICAgICAgICBzZXJ2ZXJGZWF0dXJlUHJvcHM6IHByb3BzLFxuICAgICAgfVxuICAgIH0sXG4gICAga2V5OiAncGFyYWdyYXBoJyxcbiAgICBzZXJ2ZXJGZWF0dXJlUHJvcHM6IHByb3BzLFxuICB9XG59XG4iXSwibmFtZXMiOlsiUGFyYWdyYXBoRmVhdHVyZUNsaWVudENvbXBvbmVudCIsIlBhcmFncmFwaEZlYXR1cmUiLCJwcm9wcyIsImZlYXR1cmUiLCJDbGllbnRDb21wb25lbnQiLCJjbGllbnRGZWF0dXJlUHJvcHMiLCJzZXJ2ZXJGZWF0dXJlUHJvcHMiLCJrZXkiXSwibWFwcGluZ3MiOiJBQUVBLFNBQVNBLCtCQUErQixRQUFRLG1CQUFrQjtBQUVsRSxPQUFPLE1BQU1DLG1CQUF3RSxDQUFDQztJQUNwRixPQUFPO1FBQ0xDLFNBQVM7WUFDUCxPQUFPO2dCQUNMQyxpQkFBaUJKO2dCQUNqQkssb0JBQW9CO2dCQUNwQkMsb0JBQW9CSjtZQUN0QjtRQUNGO1FBQ0FLLEtBQUs7UUFDTEQsb0JBQW9CSjtJQUN0QjtBQUNGLEVBQUMifQ==

package/dist/field/features/relationship/drawer/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/relationship/drawer/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,eAAO,MAAM,uCAAuC,EAAE,cAAc,CAAC;IACnE,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAA4D,CAAA"}

package/dist/field/features/relationship/drawer/commands.js

@@ -0,0 +1,4 @@
+import { createCommand } from 'lexical';
+export const INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND = createCommand('INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND');
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9yZWxhdGlvbnNoaXAvZHJhd2VyL2NvbW1hbmRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGV4aWNhbENvbW1hbmQgfSBmcm9tICdsZXhpY2FsJ1xuXG5pbXBvcnQgeyBjcmVhdGVDb21tYW5kIH0gZnJvbSAnbGV4aWNhbCdcblxuZXhwb3J0IGNvbnN0IElOU0VSVF9SRUxBVElPTlNISVBfV0lUSF9EUkFXRVJfQ09NTUFORDogTGV4aWNhbENvbW1hbmQ8e1xuICByZXBsYWNlOiB7IG5vZGVLZXk6IHN0cmluZyB9IHwgZmFsc2Vcbn0+ID0gY3JlYXRlQ29tbWFuZCgnSU5TRVJUX1JFTEFUSU9OU0hJUF9XSVRIX0RSQVdFUl9DT01NQU5EJylcbiJdLCJuYW1lcyI6WyJjcmVhdGVDb21tYW5kIiwiSU5TRVJUX1JFTEFUSU9OU0hJUF9XSVRIX0RSQVdFUl9DT01NQU5EIl0sIm1hcHBpbmdzIjoiQUFFQSxTQUFTQSxhQUFhLFFBQVEsVUFBUztBQUV2QyxPQUFPLE1BQU1DLDBDQUVSRCxjQUFjLDJDQUEwQyJ9

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":"AAIA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAmC/D,KAAK,KAAK,GAAG;IACX,sBAAsB,EAAE,IAAI,GAAG,MAAM,EAAE,CAAA;CACxC,CAAA;AAkDD,eAAO,MAAM,kBAAkB,UAAW,KAAK,KAAG,MAAM,SAQvD,CAAA"}

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

@@ -0,0 +1,79 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useListDrawer } from '@payloadcms/ui';
+import { $getNodeByKey, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import React, { useCallback, useEffect, useState } from 'react';
+import { $createRelationshipNode } from '../nodes/RelationshipNode';
+import { INSERT_RELATIONSHIP_COMMAND } from '../plugins';
+import { EnabledRelationshipsCondition } from '../utils/EnabledRelationshipsCondition';
+import { INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND } from './commands';
+const insertRelationship = ({ id, editor, relationTo, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(INSERT_RELATIONSHIP_COMMAND, {
+            relationTo,
+            value: {
+                id
+            }
+        });
+    } else {
+        editor.update(()=>{
+            const node = $getNodeByKey(replaceNodeKey);
+            if (node) {
+                node.replace($createRelationshipNode({
+                    relationTo,
+                    value: {
+                        id
+                    }
+                }));
+            }
+        });
+    }
+};
+const RelationshipDrawerComponent = ({ enabledCollectionSlugs })=>{
+    const [editor] = useLexicalComposerContext();
+    const [selectedCollectionSlug, setSelectedCollectionSlug] = useState(()=>enabledCollectionSlugs[0]);
+    const [replaceNodeKey, setReplaceNodeKey] = useState(null);
+    const [ListDrawer, ListDrawerToggler, { closeDrawer, isDrawerOpen, openDrawer }] = useListDrawer({
+        collectionSlugs: enabledCollectionSlugs,
+        selectedCollection: selectedCollectionSlug
+    });
+    useEffect(()=>{
+        return editor.registerCommand(INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openDrawer();
+            return true;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        openDrawer
+    ]);
+    const onSelect = useCallback(({ collectionSlug, docID })=>{
+        insertRelationship({
+            id: docID,
+            editor,
+            relationTo: collectionSlug,
+            replaceNodeKey
+        });
+        closeDrawer();
+    }, [
+        editor,
+        closeDrawer,
+        replaceNodeKey
+    ]);
+    useEffect(()=>{
+        // always reset back to first option
+        // TODO: this is not working, see the ListDrawer component
+        setSelectedCollectionSlug(enabledCollectionSlugs[0]);
+    }, [
+        isDrawerOpen,
+        enabledCollectionSlugs
+    ]);
+    return /*#__PURE__*/ React.createElement(ListDrawer, {
+        onSelect: onSelect
+    });
+};
+export const RelationshipDrawer = (props)=>{
+    return props?.enabledCollectionSlugs?.length > 0 ? /*#__PURE__*/ React.createElement(RelationshipDrawerComponent, props) : /*#__PURE__*/ React.createElement(EnabledRelationshipsCondition, props, /*#__PURE__*/ React.createElement(RelationshipDrawerComponent, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/relationship/feature.client.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { RelationshipFeatureProps } from './feature.server';
+export declare const RelationshipFeatureClientComponent: import("react").FC<import("../types").ClientComponentProps<RelationshipFeatureProps>>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/relationship/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/relationship/feature.client.tsx"],"names":[],"mappings":";AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAmDhE,eAAO,MAAM,kCAAkC,uFAAmD,CAAA"}

package/dist/field/features/relationship/feature.client.js

@@ -0,0 +1,56 @@
+'use client';
+import { withMergedProps } from '@payloadcms/ui';
+import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types';
+import { RelationshipIcon } from '../../lexical/ui/icons/Relationship';
+import { createClientComponent } from '../createClientComponent';
+import { INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND } from './drawer/commands';
+import { RelationshipNode } from './nodes/RelationshipNode';
+import { RelationshipPlugin } from './plugins';
+const RelationshipFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                nodes: [
+                    RelationshipNode
+                ],
+                plugins: [
+                    {
+                        Component: withMergedProps({
+                            Component: RelationshipPlugin,
+                            toMergeIntoProps: props
+                        }),
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    options: [
+                        {
+                            displayName: 'Basic',
+                            key: 'basic',
+                            options: [
+                                new SlashMenuOption('relationship', {
+                                    Icon: RelationshipIcon,
+                                    displayName: 'Relationship',
+                                    keywords: [
+                                        'relationship',
+                                        'relation',
+                                        'rel'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        // dispatch INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND
+                                        editor.dispatchCommand(INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, {
+                                            replace: false
+                                        });
+                                    }
+                                })
+                            ]
+                        }
+                    ]
+                }
+            })
+    };
+};
+export const RelationshipFeatureClientComponent = createClientComponent(RelationshipFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/relationship/feature.server.d.ts

@@ -0,0 +1,18 @@
+import type { FeatureProviderProviderServer } from '../types';
+export type RelationshipFeatureProps = {
+    /**
+     * The collections that should be disabled. Overrides the `enableRichTextRelationship` property in the collection config.
+     * When this property is set, `enabledCollections` will not be available.
+     **/
+    disabledCollections?: string[];
+    enabledCollections?: never;
+} | {
+    disabledCollections?: never;
+    /**
+     * The collections that should be enabled. Overrides the `enableRichTextRelationship` property in the collection config
+     * When this property is set, `disabledCollections` will not be available.
+     **/
+    enabledCollections?: string[];
+};
+export declare const RelationshipFeature: FeatureProviderProviderServer<RelationshipFeatureProps, RelationshipFeatureProps>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/relationship/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/relationship/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAM7D,MAAM,MAAM,wBAAwB,GAChC;IACE;;;QAGI;IACJ,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAA;IAG9B,kBAAkB,CAAC,EAAE,KAAK,CAAA;CAC3B,GACD;IAEE,mBAAmB,CAAC,EAAE,KAAK,CAAA;IAE3B;;;QAGI;IACJ,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA;AAEL,eAAO,MAAM,mBAAmB,EAAE,6BAA6B,CAC7D,wBAAwB,EACxB,wBAAwB,CAoBzB,CAAA"}

package/dist/field/features/relationship/feature.server.js

@@ -0,0 +1,26 @@
+import { RelationshipFeatureClientComponent } from './feature.client';
+import { RelationshipNode } from './nodes/RelationshipNode';
+import { relationshipPopulationPromise } from './populationPromise';
+export const RelationshipFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: RelationshipFeatureClientComponent,
+                clientFeatureProps: props,
+                nodes: [
+                    {
+                        node: RelationshipNode,
+                        populationPromises: [
+                            relationshipPopulationPromise
+                        ]
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'relationship',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9yZWxhdGlvbnNoaXAvZmVhdHVyZS5zZXJ2ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGZWF0dXJlUHJvdmlkZXJQcm92aWRlclNlcnZlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBSZWxhdGlvbnNoaXBGZWF0dXJlQ2xpZW50Q29tcG9uZW50IH0gZnJvbSAnLi9mZWF0dXJlLmNsaWVudCdcbmltcG9ydCB7IFJlbGF0aW9uc2hpcE5vZGUgfSBmcm9tICcuL25vZGVzL1JlbGF0aW9uc2hpcE5vZGUnXG5pbXBvcnQgeyByZWxhdGlvbnNoaXBQb3B1bGF0aW9uUHJvbWlzZSB9IGZyb20gJy4vcG9wdWxhdGlvblByb21pc2UnXG5cbmV4cG9ydCB0eXBlIFJlbGF0aW9uc2hpcEZlYXR1cmVQcm9wcyA9XG4gIHwge1xuICAgICAgLyoqXG4gICAgICAgKiBUaGUgY29sbGVjdGlvbnMgdGhhdCBzaG91bGQgYmUgZGlzYWJsZWQuIE92ZXJyaWRlcyB0aGUgYGVuYWJsZVJpY2hUZXh0UmVsYXRpb25zaGlwYCBwcm9wZXJ0eSBpbiB0aGUgY29sbGVjdGlvbiBjb25maWcuXG4gICAgICAgKiBXaGVuIHRoaXMgcHJvcGVydHkgaXMgc2V0LCBgZW5hYmxlZENvbGxlY3Rpb25zYCB3aWxsIG5vdCBiZSBhdmFpbGFibGUuXG4gICAgICAgKiovXG4gICAgICBkaXNhYmxlZENvbGxlY3Rpb25zPzogc3RyaW5nW11cblxuICAgICAgLy8gRW5zdXJlcyB0aGF0IGVuYWJsZWRDb2xsZWN0aW9ucyBpcyBub3QgYXZhaWxhYmxlIHdoZW4gZGlzYWJsZWRDb2xsZWN0aW9ucyBpcyBzZXRcbiAgICAgIGVuYWJsZWRDb2xsZWN0aW9ucz86IG5ldmVyXG4gICAgfVxuICB8IHtcbiAgICAgIC8vIEVuc3VyZXMgdGhhdCBkaXNhYmxlZENvbGxlY3Rpb25zIGlzIG5vdCBhdmFpbGFibGUgd2hlbiBlbmFibGVkQ29sbGVjdGlvbnMgaXMgc2V0XG4gICAgICBkaXNhYmxlZENvbGxlY3Rpb25zPzogbmV2ZXJcblxuICAgICAgLyoqXG4gICAgICAgKiBUaGUgY29sbGVjdGlvbnMgdGhhdCBzaG91bGQgYmUgZW5hYmxlZC4gT3ZlcnJpZGVzIHRoZSBgZW5hYmxlUmljaFRleHRSZWxhdGlvbnNoaXBgIHByb3BlcnR5IGluIHRoZSBjb2xsZWN0aW9uIGNvbmZpZ1xuICAgICAgICogV2hlbiB0aGlzIHByb3BlcnR5IGlzIHNldCwgYGRpc2FibGVkQ29sbGVjdGlvbnNgIHdpbGwgbm90IGJlIGF2YWlsYWJsZS5cbiAgICAgICAqKi9cbiAgICAgIGVuYWJsZWRDb2xsZWN0aW9ucz86IHN0cmluZ1tdXG4gICAgfVxuXG5leHBvcnQgY29uc3QgUmVsYXRpb25zaGlwRmVhdHVyZTogRmVhdHVyZVByb3ZpZGVyUHJvdmlkZXJTZXJ2ZXI8XG4gIFJlbGF0aW9uc2hpcEZlYXR1cmVQcm9wcyxcbiAgUmVsYXRpb25zaGlwRmVhdHVyZVByb3BzXG4+ID0gKHByb3BzKSA9PiB7XG4gIHJldHVybiB7XG4gICAgZmVhdHVyZTogKCkgPT4ge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgQ2xpZW50Q29tcG9uZW50OiBSZWxhdGlvbnNoaXBGZWF0dXJlQ2xpZW50Q29tcG9uZW50LFxuICAgICAgICBjbGllbnRGZWF0dXJlUHJvcHM6IHByb3BzLFxuICAgICAgICBub2RlczogW1xuICAgICAgICAgIHtcbiAgICAgICAgICAgIG5vZGU6IFJlbGF0aW9uc2hpcE5vZGUsXG4gICAgICAgICAgICBwb3B1bGF0aW9uUHJvbWlzZXM6IFtyZWxhdGlvbnNoaXBQb3B1bGF0aW9uUHJvbWlzZV0sXG4gICAgICAgICAgICAvLyBUT0RPOiBBZGQgdmFsaWRhdGlvbiBzaW1pbGFyIHRvIHVwbG9hZFxuICAgICAgICAgIH0sXG4gICAgICAgIF0sXG4gICAgICAgIHNlcnZlckZlYXR1cmVQcm9wczogcHJvcHMsXG4gICAgICB9XG4gICAgfSxcbiAgICBrZXk6ICdyZWxhdGlvbnNoaXAnLFxuICAgIHNlcnZlckZlYXR1cmVQcm9wczogcHJvcHMsXG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJSZWxhdGlvbnNoaXBGZWF0dXJlQ2xpZW50Q29tcG9uZW50IiwiUmVsYXRpb25zaGlwTm9kZSIsInJlbGF0aW9uc2hpcFBvcHVsYXRpb25Qcm9taXNlIiwiUmVsYXRpb25zaGlwRmVhdHVyZSIsInByb3BzIiwiZmVhdHVyZSIsIkNsaWVudENvbXBvbmVudCIsImNsaWVudEZlYXR1cmVQcm9wcyIsIm5vZGVzIiwibm9kZSIsInBvcHVsYXRpb25Qcm9taXNlcyIsInNlcnZlckZlYXR1cmVQcm9wcyIsImtleSJdLCJtYXBwaW5ncyI6IkFBRUEsU0FBU0Esa0NBQWtDLFFBQVEsbUJBQWtCO0FBQ3JFLFNBQVNDLGdCQUFnQixRQUFRLDJCQUEwQjtBQUMzRCxTQUFTQyw2QkFBNkIsUUFBUSxzQkFBcUI7QUF3Qm5FLE9BQU8sTUFBTUMsc0JBR1QsQ0FBQ0M7SUFDSCxPQUFPO1FBQ0xDLFNBQVM7WUFDUCxPQUFPO2dCQUNMQyxpQkFBaUJOO2dCQUNqQk8sb0JBQW9CSDtnQkFDcEJJLE9BQU87b0JBQ0w7d0JBQ0VDLE1BQU1SO3dCQUNOUyxvQkFBb0I7NEJBQUNSO3lCQUE4QjtvQkFFckQ7aUJBQ0Q7Z0JBQ0RTLG9CQUFvQlA7WUFDdEI7UUFDRjtRQUNBUSxLQUFLO1FBQ0xELG9CQUFvQlA7SUFDdEI7QUFDRixFQUFDIn0=

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;AAUjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE;QAEL,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;QACtB,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,gBAAgB,EAAE,4BAA4B,CAAC,CAAA;AAkB/F,qBAAa,gBAAiB,SAAQ,kBAAkB;IACtD,MAAM,EAAE,gBAAgB,CAAA;gBAEZ,EACV,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;QACD,IAAI,EAAE,gBAAgB,CAAA;QACtB,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;IAU/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,OAAO,IAAI,gBAAgB;IAI3B,cAAc,IAAI,MAAM;IAIxB,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;CAItC;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CAIhF;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,110 @@
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import * as React from 'react';
+const RelationshipComponent = /*#__PURE__*/ React.lazy(()=>// @ts-expect-error-next-line TypeScript being dumb
+    import('./components/RelationshipComponent').then((module)=>({
+            default: module.RelationshipComponent
+        })));
+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({
+            relationTo,
+            value: {
+                id
+            }
+        });
+        return {
+            node
+        };
+    }
+    return null;
+}
+export class RelationshipNode extends DecoratorBlockNode {
+    __data;
+    constructor({ data, format, key }){
+        super(format, key);
+        this.__data = data;
+    }
+    static clone(node) {
+        return new RelationshipNode({
+            data: node.__data,
+            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 importedData = {
+            relationTo: serializedNode.relationTo,
+            value: serializedNode.value
+        };
+        const node = $createRelationshipNode(importedData);
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate(editor, config) {
+        return /*#__PURE__*/ React.createElement(RelationshipComponent, {
+            className: config.theme.relationship ?? 'LexicalEditorTheme__relationship',
+            data: this.__data,
+            format: this.__format,
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.setAttribute('data-lexical-relationship-id', this.__data?.value?.id);
+        element.setAttribute('data-lexical-relationship-relationTo', this.__data?.relationTo);
+        const text = document.createTextNode(this.getTextContent());
+        element.append(text);
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            ...this.getData(),
+            type: this.getType(),
+            version: 1
+        };
+    }
+    getData() {
+        return this.getLatest().__data;
+    }
+    getTextContent() {
+        return `${this.__data?.relationTo} relation to ${this.__data?.value?.id}`;
+    }
+    setData(data) {
+        const writable = this.getWritable();
+        writable.__data = data;
+    }
+}
+export function $createRelationshipNode(data) {
+    return new RelationshipNode({
+        data
+    });
+}
+export 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\nconst RelationshipComponent = React.lazy(() =>\n  // @ts-expect-error-next-line TypeScript being dumb\n  import('./components/RelationshipComponent').then((module) => ({\n    default: module.RelationshipComponent,\n  })),\n)\n\nexport type RelationshipData = {\n  relationTo: string\n  value: {\n    // Actual relationship, populated in afterRead hook\n    [key: string]: unknown\n    id: string\n  }\n}\n\nexport type SerializedRelationshipNode = Spread<RelationshipData, SerializedDecoratorBlockNode>\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      relationTo,\n      value: {\n        id,\n      },\n    })\n    return { node }\n  }\n  return null\n}\n\nexport class RelationshipNode extends DecoratorBlockNode {\n  __data: RelationshipData\n\n  constructor({\n    data,\n    format,\n    key,\n  }: {\n    data: RelationshipData\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__data = data\n  }\n\n  static clone(node: RelationshipNode): RelationshipNode {\n    return new RelationshipNode({\n      data: node.__data,\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 importedData: RelationshipData = {\n      relationTo: serializedNode.relationTo,\n      value: serializedNode.value,\n    }\n    const node = $createRelationshipNode(importedData)\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        data={this.__data}\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.__data?.value?.id)\n    element.setAttribute('data-lexical-relationship-relationTo', this.__data?.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      ...this.getData(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  getData(): RelationshipData {\n    return this.getLatest().__data\n  }\n\n  getTextContent(): string {\n    return `${this.__data?.relationTo} relation to ${this.__data?.value?.id}`\n  }\n\n  setData(data: RelationshipData): void {\n    const writable = this.getWritable()\n    writable.__data = data\n  }\n}\n\nexport function $createRelationshipNode(data: RelationshipData): RelationshipNode {\n  return new RelationshipNode({\n    data,\n  })\n}\n\nexport function $isRelationshipNode(\n  node: LexicalNode | RelationshipNode | null | undefined,\n): node is RelationshipNode {\n  return node instanceof RelationshipNode\n}\n"],"names":["DecoratorBlockNode","React","RelationshipComponent","lazy","then","module","default","relationshipElementToNode","domNode","id","getAttribute","relationTo","node","$createRelationshipNode","value","RelationshipNode","__data","constructor","data","format","key","clone","__format","__key","getType","importDOM","div","hasAttribute","conversion","priority","importJSON","serializedNode","importedData","setFormat","isInline","decorate","editor","config","className","theme","relationship","nodeKey","getKey","exportDOM","element","document","createElement","setAttribute","text","createTextNode","getTextContent","append","exportJSON","getData","type","version","getLatest","setData","writable","getWritable","$isRelationshipNode"],"mappings":"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"}

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":"AAKA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC/D,OAAO,KAA4C,MAAM,OAAO,CAAA;AAEhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAI3D,OAAO,cAAc,CAAA;AAQrB,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,gBAAgB,CAAA;IACtB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AA8GD,eAAO,MAAM,qBAAqB,UAAW,KAAK,KAAG,MAAM,SAE1D,CAAA"}

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

@@ -0,0 +1,103 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { getTranslation } from '@payloadcms/translations';
+import { Button, useConfig, useDocumentDrawer, usePayloadAPI, useTranslation } from '@payloadcms/ui';
+import { $getNodeByKey } from 'lexical';
+import React, { useCallback, useReducer, useState } from 'react';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider';
+import { INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND } from '../../drawer/commands';
+import './index.scss';
+const baseClass = 'lexical-relationship';
+const initialParams = {
+    depth: 0
+};
+const Component = (props)=>{
+    const { children, data: { relationTo, value: { id } }, nodeKey } = props;
+    const [editor] = useLexicalComposerContext();
+    const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+    const { field } = useEditorConfigContext();
+    const { collections, routes: { api }, serverURL } = useConfig();
+    const [relatedCollection, setRelatedCollection] = useState(()=>collections.find((coll)=>coll.slug === relationTo));
+    const { i18n, t } = useTranslation();
+    const [cacheBust, dispatchCacheBust] = useReducer((state)=>state + 1, 0);
+    const [{ data }, { setParams }] = usePayloadAPI(`${serverURL}${api}/${relatedCollection.slug}/${id}`, {
+        initialParams
+    });
+    const [DocumentDrawer, DocumentDrawerToggler, { closeDrawer }] = useDocumentDrawer({
+        id,
+        collectionSlug: relatedCollection.slug
+    });
+    const removeRelationship = useCallback(()=>{
+        editor.update(()=>{
+            $getNodeByKey(nodeKey).remove();
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    const updateRelationship = React.useCallback(({ doc })=>{
+        setParams({
+            ...initialParams,
+            cacheBust
+        });
+        closeDrawer();
+        dispatchCacheBust();
+    }, [
+        cacheBust,
+        setParams,
+        closeDrawer
+    ]);
+    return /*#__PURE__*/ React.createElement("div", {
+        className: [
+            baseClass,
+            isSelected && `${baseClass}--selected`
+        ].filter(Boolean).join(' '),
+        contentEditable: false
+    }, /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__wrap`
+    }, /*#__PURE__*/ React.createElement("p", {
+        className: `${baseClass}__label`
+    }, t('fields:labelRelationship', {
+        label: getTranslation(relatedCollection.labels.singular, i18n)
+    })), /*#__PURE__*/ React.createElement(DocumentDrawerToggler, {
+        className: `${baseClass}__doc-drawer-toggler`
+    }, /*#__PURE__*/ React.createElement("p", {
+        className: `${baseClass}__title`
+    }, data ? data[relatedCollection?.admin?.useAsTitle || 'id'] : id))), editor.isEditable() && /*#__PURE__*/ React.createElement("div", {
+        className: `${baseClass}__actions`
+    }, /*#__PURE__*/ React.createElement(Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__swapButton`,
+        disabled: field?.readOnly,
+        el: "div",
+        icon: "swap",
+        onClick: ()=>{
+            editor.dispatchCommand(INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND, {
+                replace: {
+                    nodeKey
+                }
+            });
+        },
+        round: true,
+        tooltip: t('fields:swapRelationship')
+    }), /*#__PURE__*/ React.createElement(Button, {
+        buttonStyle: "icon-label",
+        className: `${baseClass}__removeButton`,
+        disabled: field?.readOnly,
+        icon: "x",
+        onClick: (e)=>{
+            e.preventDefault();
+            removeRelationship();
+        },
+        round: true,
+        tooltip: t('fields:removeRelationship')
+    })), id && /*#__PURE__*/ React.createElement(DocumentDrawer, {
+        onSave: updateRelationship
+    }), children);
+};
+export const RelationshipComponent = (props)=>{
+    return /*#__PURE__*/ React.createElement(Component, props);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/relationship/nodes/components/RelationshipComponent.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection'\nimport { getTranslation } from '@payloadcms/translations'\nimport { Button, useConfig, useDocumentDrawer, usePayloadAPI, useTranslation } from '@payloadcms/ui'\nimport { $getNodeByKey, type ElementFormatType } from 'lexical'\nimport React, { useCallback, useReducer, useState } from 'react'\n\nimport type { RelationshipData } from '../RelationshipNode'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider'\nimport { INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND } from '../../drawer/commands'\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  data: RelationshipData\n  format?: ElementFormatType\n  nodeKey?: string\n}\n\nconst Component: React.FC<Props> = (props) => {\n  const {\n    children,\n    data: {\n      relationTo,\n      value: { id },\n    },\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()\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,\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('fields: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 ? data[relatedCollection?.admin?.useAsTitle || 'id'] : id}\n          </p>\n        </DocumentDrawerToggler>\n      </div>\n      {editor.isEditable() && (\n        <div className={`${baseClass}__actions`}>\n          <Button\n            buttonStyle=\"icon-label\"\n            className={`${baseClass}__swapButton`}\n            disabled={field?.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('fields:swapRelationship')}\n          />\n          <Button\n            buttonStyle=\"icon-label\"\n            className={`${baseClass}__removeButton`}\n            disabled={field?.readOnly}\n            icon=\"x\"\n            onClick={(e) => {\n              e.preventDefault()\n              removeRelationship()\n            }}\n            round\n            tooltip={t('fields:removeRelationship')}\n          />\n        </div>\n      )}\n\n      {id && <DocumentDrawer onSave={updateRelationship} />}\n      {children}\n    </div>\n  )\n}\n\nexport const RelationshipComponent = (props: Props): React.ReactNode => {\n  return <Component {...props} />\n}\n"],"names":["useLexicalComposerContext","useLexicalNodeSelection","getTranslation","Button","useConfig","useDocumentDrawer","usePayloadAPI","useTranslation","$getNodeByKey","React","useCallback","useReducer","useState","useEditorConfigContext","INSERT_RELATIONSHIP_WITH_DRAWER_COMMAND","baseClass","initialParams","depth","Component","props","children","data","relationTo","value","id","nodeKey","editor","isSelected","setSelected","clearSelection","field","collections","routes","api","serverURL","relatedCollection","setRelatedCollection","find","coll","slug","i18n","t","cacheBust","dispatchCacheBust","state","setParams","DocumentDrawer","DocumentDrawerToggler","closeDrawer","collectionSlug","removeRelationship","update","remove","updateRelationship","doc","div","className","filter","Boolean","join","contentEditable","p","label","labels","singular","admin","useAsTitle","isEditable","buttonStyle","disabled","readOnly","el","icon","onClick","dispatchCommand","replace","round","tooltip","e","preventDefault","onSave","RelationshipComponent"],"mappings":"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"}