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

package/dist/field/features/heading/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/field/features/heading/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAMxD,eAAO,MAAM,mBAAmB,EAAE,CAAC,mBAAmB,EAAE,cAAc,EAAE,KAAK,kBA0B5E,CAAA"}

package/dist/field/features/heading/markdownTransformer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkdownTransformer", {
+    enumerable: true,
+    get: function() {
+        return MarkdownTransformer;
+    }
+});
+const _richtext = require("@lexical/rich-text");
+const _createBlockNode = require("../../lexical/utils/markdown/createBlockNode");
+const MarkdownTransformer = (enabledHeadingSizes)=>{
+    // Convert enabledHeadingSizes to a list of numbers (1 for h1, 2 for h2, etc.)
+    const enabledSizes = enabledHeadingSizes.map((tag)=>Number(tag.slice(1)));
+    // Create a regex pattern that matches any of the enabled sizes
+    const pattern = `^(${enabledSizes.map((size)=>`#{${size}}`).join('|')})\\s`;
+    const regExp = new RegExp(pattern);
+    return {
+        type: 'element',
+        dependencies: [
+            _richtext.HeadingNode
+        ],
+        export: (node, exportChildren)=>{
+            if (!(0, _richtext.$isHeadingNode)(node)) {
+                return null;
+            }
+            const level = Number(node.getTag().slice(1));
+            return '#'.repeat(level) + ' ' + exportChildren(node);
+        },
+        regExp,
+        replace: (0, _createBlockNode.createBlockNode)((match)=>{
+            const tag = 'h' + match[1].length;
+            return (0, _richtext.$createHeadingNode)(tag);
+        })
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/feature.client.tsx"],"names":[],"mappings":";AAiEA,eAAO,MAAM,4BAA4B,+BAA6C,CAAA"}

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

@@ -0,0 +1,67 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IndentFeatureClientComponent", {
+    enumerable: true,
+    get: function() {
+        return IndentFeatureClientComponent;
+    }
+});
+const _lexical = require("lexical");
+const _IndentDecrease = require("../../lexical/ui/icons/IndentDecrease");
+const _IndentIncrease = require("../../lexical/ui/icons/IndentIncrease");
+const _createClientComponent = require("../createClientComponent");
+const _floatingSelectToolbarIndentSection = require("./floatingSelectToolbarIndentSection");
+const IndentFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                floatingSelectToolbar: {
+                    sections: [
+                        (0, _floatingSelectToolbarIndentSection.IndentSectionWithEntries)([
+                            {
+                                ChildComponent: _IndentDecrease.IndentDecreaseIcon,
+                                isActive: ()=>false,
+                                isEnabled: ({ selection })=>{
+                                    if (!selection || !selection?.getNodes()?.length) {
+                                        return false;
+                                    }
+                                    for (const node of selection.getNodes()){
+                                        // If at least one node is indented, this should be active
+                                        if ('__indent' in node && node.__indent > 0 || node.getParent() && '__indent' in node.getParent() && node.getParent().__indent > 0) {
+                                            return true;
+                                        }
+                                    }
+                                    return false;
+                                },
+                                key: 'indent-decrease',
+                                label: `Decrease Indent`,
+                                onClick: ({ editor })=>{
+                                    editor.dispatchCommand(_lexical.OUTDENT_CONTENT_COMMAND, undefined);
+                                },
+                                order: 1
+                            }
+                        ]),
+                        (0, _floatingSelectToolbarIndentSection.IndentSectionWithEntries)([
+                            {
+                                ChildComponent: _IndentIncrease.IndentIncreaseIcon,
+                                isActive: ()=>false,
+                                key: 'indent-increase',
+                                label: `Increase Indent`,
+                                onClick: ({ editor })=>{
+                                    editor.dispatchCommand(_lexical.INDENT_CONTENT_COMMAND, undefined);
+                                },
+                                order: 2
+                            }
+                        ])
+                    ]
+                }
+            })
+    };
+};
+const IndentFeatureClientComponent = (0, _createClientComponent.createClientComponent)(IndentFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IndentFeature", {
+    enumerable: true,
+    get: function() {
+        return IndentFeature;
+    }
+});
+const _featureclient = require("./feature.client");
+const IndentFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: _featureclient.IndentFeatureClientComponent,
+                clientFeatureProps: null,
+                serverFeatureProps: props
+            };
+        },
+        key: 'indent',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9pbmRlbnQvZmVhdHVyZS5zZXJ2ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGZWF0dXJlUHJvdmlkZXJQcm92aWRlclNlcnZlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBJbmRlbnRGZWF0dXJlQ2xpZW50Q29tcG9uZW50IH0gZnJvbSAnLi9mZWF0dXJlLmNsaWVudCdcblxuZXhwb3J0IGNvbnN0IEluZGVudEZlYXR1cmU6IEZlYXR1cmVQcm92aWRlclByb3ZpZGVyU2VydmVyPHVuZGVmaW5lZCwgdW5kZWZpbmVkPiA9IChwcm9wcykgPT4ge1xuICByZXR1cm4ge1xuICAgIGZlYXR1cmU6ICgpID0+IHtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIENsaWVudENvbXBvbmVudDogSW5kZW50RmVhdHVyZUNsaWVudENvbXBvbmVudCxcbiAgICAgICAgY2xpZW50RmVhdHVyZVByb3BzOiBudWxsLFxuICAgICAgICBzZXJ2ZXJGZWF0dXJlUHJvcHM6IHByb3BzLFxuICAgICAgfVxuICAgIH0sXG4gICAga2V5OiAnaW5kZW50JyxcbiAgICBzZXJ2ZXJGZWF0dXJlUHJvcHM6IHByb3BzLFxuICB9XG59XG4iXSwibmFtZXMiOlsiSW5kZW50RmVhdHVyZSIsInByb3BzIiwiZmVhdHVyZSIsIkNsaWVudENvbXBvbmVudCIsIkluZGVudEZlYXR1cmVDbGllbnRDb21wb25lbnQiLCJjbGllbnRGZWF0dXJlUHJvcHMiLCJzZXJ2ZXJGZWF0dXJlUHJvcHMiLCJrZXkiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7OzsrQkFGZ0M7QUFFdEMsTUFBTUEsZ0JBQXFFLENBQUNDO0lBQ2pGLE9BQU87UUFDTEMsU0FBUztZQUNQLE9BQU87Z0JBQ0xDLGlCQUFpQkMsMkNBQTRCO2dCQUM3Q0Msb0JBQW9CO2dCQUNwQkMsb0JBQW9CTDtZQUN0QjtRQUNGO1FBQ0FNLEtBQUs7UUFDTEQsb0JBQW9CTDtJQUN0QjtBQUNGIn0=

package/dist/field/features/indent/floatingSelectToolbarIndentSection.js

@@ -10,11 +10,11 @@ Object.defineProperty(exports, "IndentSectionWithEntries", {
 });
 const IndentSectionWithEntries = (entries)=>{
     return {
+        type: 'buttons',
         entries,
         key: 'indent',
-        order: 3,
-        type: 'buttons'
+        order: 3
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9pbmRlbnQvZmxvYXRpbmdTZWxlY3RUb29sYmFySW5kZW50U2VjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb24sXG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSxcbn0gZnJvbSAnLi4vLi4vbGV4aWNhbC9wbHVnaW5zL0Zsb2F0aW5nU2VsZWN0VG9vbGJhci90eXBlcydcblxuZXhwb3J0IGNvbnN0IEluZGVudFNlY3Rpb25XaXRoRW50cmllcyA9IChcbiAgZW50cmllczogRmxvYXRpbmdUb29sYmFyU2VjdGlvbkVudHJ5W10sXG4pOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uID0+IHtcbiAgcmV0dXJuIHtcbiAgICBlbnRyaWVzLFxuICAgIGtleTogJ2luZGVudCcsXG4gICAgb3JkZXI6IDMsXG4gICAgdHlwZTogJ2J1dHRvbnMnLFxuICB9XG59XG4iXSwibmFtZXMiOlsiSW5kZW50U2VjdGlvbldpdGhFbnRyaWVzIiwiZW50cmllcyIsImtleSIsIm9yZGVyIiwidHlwZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsMkJBQTJCLENBQ3RDQztJQUVBLE9BQU87UUFDTEE7UUFDQUMsS0FBSztRQUNMQyxPQUFPO1FBQ1BDLE1BQU07SUFDUjtBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9pbmRlbnQvZmxvYXRpbmdTZWxlY3RUb29sYmFySW5kZW50U2VjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb24sXG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSxcbn0gZnJvbSAnLi4vLi4vbGV4aWNhbC9wbHVnaW5zL0Zsb2F0aW5nU2VsZWN0VG9vbGJhci90eXBlcydcblxuZXhwb3J0IGNvbnN0IEluZGVudFNlY3Rpb25XaXRoRW50cmllcyA9IChcbiAgZW50cmllczogRmxvYXRpbmdUb29sYmFyU2VjdGlvbkVudHJ5W10sXG4pOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uID0+IHtcbiAgcmV0dXJuIHtcbiAgICB0eXBlOiAnYnV0dG9ucycsXG4gICAgZW50cmllcyxcbiAgICBrZXk6ICdpbmRlbnQnLFxuICAgIG9yZGVyOiAzLFxuICB9XG59XG4iXSwibmFtZXMiOlsiSW5kZW50U2VjdGlvbldpdGhFbnRyaWVzIiwiZW50cmllcyIsInR5cGUiLCJrZXkiLCJvcmRlciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsMkJBQTJCLENBQ3RDQztJQUVBLE9BQU87UUFDTEMsTUFBTTtRQUNORDtRQUNBRSxLQUFLO1FBQ0xDLE9BQU87SUFDVDtBQUNGIn0=

package/dist/field/features/link/drawer/baseFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseFields.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/link/drawer/baseFields.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAyB,MAAM,eAAe,CAAA;AAiBjE,eAAO,MAAM,aAAa,WAChB,MAAM,sBACM,KAAK,GAAG,MAAM,EAAE,uBACf,KAAK,GAAG,MAAM,EAAE,KACpC,KAAK,EAmHP,CAAA"}

package/dist/field/features/link/drawer/baseFields.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBaseFields", {
+    enumerable: true,
+    get: function() {
+        return getBaseFields;
+    }
+});
+const _utilities = require("payload/utilities");
+const _url = require("../../../lexical/utils/url");
+const translations = (0, _utilities.extractTranslations)([
+    'fields:textToDisplay',
+    'fields:linkType',
+    'fields:chooseBetweenCustomTextOrDocument',
+    'fields:customURL',
+    'fields:internalLink',
+    'fields:enterURL',
+    'fields:chooseDocumentToLink',
+    'fields:openInNewTab'
+]);
+const getBaseFields = (config, enabledCollections, disabledCollections)=>{
+    let enabledRelations;
+    /**
+   * Figure out which relations should be enabled (enabledRelations) based on a collection's admin.enableRichTextLink property,
+   * or the Link Feature's enabledCollections and disabledCollections properties which override it.
+   */ if (enabledCollections) {
+        enabledRelations = enabledCollections;
+    } else if (disabledCollections) {
+        enabledRelations = config.collections.filter(({ slug })=>!disabledCollections.includes(slug)).map(({ slug })=>slug);
+    } else {
+        enabledRelations = config.collections.filter(({ admin: { enableRichTextLink, hidden } })=>{
+            if (typeof hidden !== 'function' && hidden) {
+                return false;
+            }
+            return enableRichTextLink;
+        }).map(({ slug })=>slug);
+    }
+    const baseFields = [
+        {
+            name: 'text',
+            type: 'text',
+            label: translations['fields:textToDisplay'],
+            required: true
+        },
+        {
+            name: 'fields',
+            type: 'group',
+            admin: {
+                style: {
+                    borderBottom: 0,
+                    borderTop: 0,
+                    margin: 0,
+                    padding: 0
+                }
+            },
+            fields: [
+                {
+                    name: 'linkType',
+                    type: 'radio',
+                    admin: {
+                        description: translations['fields:chooseBetweenCustomTextOrDocument']
+                    },
+                    defaultValue: 'custom',
+                    label: translations['fields:linkType'],
+                    options: [
+                        {
+                            label: translations['fields:customURL'],
+                            value: 'custom'
+                        }
+                    ],
+                    required: true
+                },
+                {
+                    name: 'url',
+                    type: 'text',
+                    label: translations['fields:enterURL'],
+                    required: true,
+                    validate: (value)=>{
+                        if (value && !(0, _url.validateUrl)(value)) {
+                            return 'Invalid URL';
+                        }
+                    }
+                }
+            ]
+        }
+    ];
+    // Only display internal link-specific fields / options / conditions if there are enabled relations
+    if (enabledRelations?.length) {
+        baseFields[1].fields[0].options.push({
+            label: translations['fields:internalLink'],
+            value: 'internal'
+        });
+        baseFields[1].fields[1].admin = {
+            condition: ({ fields })=>fields?.linkType !== 'internal'
+        };
+        baseFields[1].fields.push({
+            name: 'doc',
+            admin: {
+                condition: ({ fields })=>{
+                    return fields?.linkType === 'internal';
+                }
+            },
+            // when admin.hidden is a function we need to dynamically call hidden with the user to know if the collection should be shown
+            type: 'relationship',
+            filterOptions: !enabledCollections && !disabledCollections ? ({ relationTo, user })=>{
+                const hidden = config.collections.find(({ slug })=>slug === relationTo).admin.hidden;
+                if (typeof hidden === 'function' && hidden({
+                    user
+                })) {
+                    return false;
+                }
+            } : null,
+            label: translations['fields:chooseDocumentToLink'],
+            relationTo: enabledRelations,
+            required: true
+        });
+    }
+    baseFields[1].fields.push({
+        name: 'newTab',
+        type: 'checkbox',
+        label: translations['fields:openInNewTab']
+    });
+    return baseFields;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/link/drawer/baseFields.ts"],"sourcesContent":["import type { User } from 'payload/auth'\nimport type { Config } from 'payload/config'\nimport type { Field, RadioField, TextField } from 'payload/types'\n\nimport { extractTranslations } from 'payload/utilities'\n\nimport { validateUrl } from '../../../lexical/utils/url'\n\nconst translations = extractTranslations([\n  'fields:textToDisplay',\n  'fields:linkType',\n  'fields:chooseBetweenCustomTextOrDocument',\n  'fields:customURL',\n  'fields:internalLink',\n  'fields:enterURL',\n  'fields:chooseDocumentToLink',\n  'fields:openInNewTab',\n])\n\nexport const getBaseFields = (\n  config: Config,\n  enabledCollections: false | string[],\n  disabledCollections: false | string[],\n): Field[] => {\n  let enabledRelations: string[]\n\n  /**\n   * Figure out which relations should be enabled (enabledRelations) based on a collection's admin.enableRichTextLink property,\n   * or the Link Feature's enabledCollections and disabledCollections properties which override it.\n   */\n  if (enabledCollections) {\n    enabledRelations = enabledCollections\n  } else if (disabledCollections) {\n    enabledRelations = config.collections\n      .filter(({ slug }) => !disabledCollections.includes(slug))\n      .map(({ slug }) => slug)\n  } else {\n    enabledRelations = config.collections\n      .filter(({ admin: { enableRichTextLink, hidden } }) => {\n        if (typeof hidden !== 'function' && hidden) {\n          return false\n        }\n        return enableRichTextLink\n      })\n      .map(({ slug }) => slug)\n  }\n\n  const baseFields = [\n    {\n      name: 'text',\n      type: 'text',\n      label: translations['fields:textToDisplay'],\n      required: true,\n    },\n    {\n      name: 'fields',\n      type: 'group',\n      admin: {\n        style: {\n          borderBottom: 0,\n          borderTop: 0,\n          margin: 0,\n          padding: 0,\n        },\n      },\n      fields: [\n        {\n          name: 'linkType',\n          type: 'radio',\n          admin: {\n            description: translations['fields:chooseBetweenCustomTextOrDocument'],\n          },\n          defaultValue: 'custom',\n          label: translations['fields:linkType'],\n          options: [\n            {\n              label: translations['fields:customURL'],\n              value: 'custom',\n            },\n          ],\n          required: true,\n        },\n        {\n          name: 'url',\n          type: 'text',\n          label: translations['fields:enterURL'],\n          required: true,\n          validate: (value: string) => {\n            if (value && !validateUrl(value)) {\n              return 'Invalid URL'\n            }\n          },\n        },\n      ] as Field[],\n    },\n  ]\n\n  // Only display internal link-specific fields / options / conditions if there are enabled relations\n  if (enabledRelations?.length) {\n    ;(baseFields[1].fields[0] as RadioField).options.push({\n      label: translations['fields:internalLink'],\n      value: 'internal',\n    })\n    ;(baseFields[1].fields[1] as TextField).admin = {\n      condition: ({ fields }) => fields?.linkType !== 'internal',\n    }\n\n    baseFields[1].fields.push({\n      name: 'doc',\n      admin: {\n        condition: ({ fields }) => {\n          return fields?.linkType === 'internal'\n        },\n      },\n      // when admin.hidden is a function we need to dynamically call hidden with the user to know if the collection should be shown\n      type: 'relationship',\n      filterOptions:\n        !enabledCollections && !disabledCollections\n          ? ({ relationTo, user }) => {\n              const hidden = config.collections.find(({ slug }) => slug === relationTo).admin.hidden\n              if (typeof hidden === 'function' && hidden({ user } as { user: User })) {\n                return false\n              }\n            }\n          : null,\n      label: translations['fields:chooseDocumentToLink'],\n      relationTo: enabledRelations,\n      required: true,\n    })\n  }\n\n  baseFields[1].fields.push({\n    name: 'newTab',\n    type: 'checkbox',\n    label: translations['fields:openInNewTab'],\n  })\n\n  return baseFields as Field[]\n}\n"],"names":["getBaseFields","translations","extractTranslations","config","enabledCollections","disabledCollections","enabledRelations","collections","filter","slug","includes","map","admin","enableRichTextLink","hidden","baseFields","name","type","label","required","style","borderBottom","borderTop","margin","padding","fields","description","defaultValue","options","value","validate","validateUrl","length","push","condition","linkType","filterOptions","relationTo","user","find"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/link/drawer/index.tsx"],"names":[],"mappings":"AAeA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAI/D,OAAO,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAyEtC,CAAA"}

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LinkDrawer", {
+    enumerable: true,
+    get: function() {
+        return LinkDrawer;
+    }
+});
+const _ui = require("@payloadcms/ui");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _uuid = require("uuid");
+const _EditorConfigProvider = require("../../../lexical/config/client/EditorConfigProvider");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'lexical-link-edit-drawer';
+const LinkDrawer = ({ drawerSlug, handleModalSubmit, stateData })=>{
+    const { t } = (0, _ui.useTranslation)();
+    const { id } = (0, _ui.useDocumentInfo)();
+    const { schemaPath } = (0, _ui.useFieldPath)();
+    const config = (0, _ui.useConfig)();
+    const [initialState, setInitialState] = (0, _react.useState)(false);
+    const { field: { richTextComponentMap } } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const componentMapRenderedFieldsPath = `feature.link.fields.fields`;
+    const schemaFieldsPath = `${schemaPath}.feature.link.fields`;
+    const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema
+    ;
+    (0, _react.useEffect)(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await (0, _ui.getFormState)({
+                apiRoute: config.routes.api,
+                body: {
+                    id,
+                    data: stateData,
+                    operation: 'update',
+                    schemaPath: schemaFieldsPath
+                },
+                serverURL: config.serverURL
+            }) // Form State
+            ;
+            setInitialState(state);
+        };
+        if (stateData) {
+            void awaitInitialState();
+        }
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id,
+        stateData
+    ]);
+    const onChange = (0, _react.useCallback)(async ({ formState: prevFormState })=>{
+        return await (0, _ui.getFormState)({
+            apiRoute: config.routes.api,
+            body: {
+                id,
+                formState: prevFormState,
+                operation: 'update',
+                schemaPath: schemaFieldsPath
+            },
+            serverURL: config.serverURL
+        });
+    }, [
+        config.routes.api,
+        config.serverURL,
+        schemaFieldsPath,
+        id
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_ui.Drawer, {
+        className: baseClass,
+        slug: drawerSlug,
+        title: t('fields:editLink') ?? ''
+    }, initialState !== false && /*#__PURE__*/ _react.default.createElement(_ui.FieldPathProvider, {
+        path: "",
+        schemaPath: ""
+    }, /*#__PURE__*/ _react.default.createElement(_ui.Form, {
+        // @ts-expect-error // TODO: Fix this type. Is this correct?
+        fields: Array.isArray(fieldMap) ? fieldMap : [],
+        initialState: initialState,
+        onChange: [
+            onChange
+        ],
+        onSubmit: handleModalSubmit,
+        uuid: (0, _uuid.v4)()
+    }, /*#__PURE__*/ _react.default.createElement(_ui.RenderFields, {
+        fieldMap: Array.isArray(fieldMap) ? fieldMap : [],
+        forceRender: true
+    }), /*#__PURE__*/ _react.default.createElement(_ui.FormSubmit, null, t('general:submit')))));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/link/drawer/index.scss

@@ -0,0 +1,50 @@
+@import '../../../../scss/styles.scss';
+
+.lexical-link-edit-drawer {
+  &__template {
+    position: relative;
+    z-index: 1;
+    padding-top: var(--base);
+    padding-bottom: calc(var(--base) * 2);
+  }
+
+  &__header {
+    width: 100%;
+    margin-bottom: var(--base);
+    display: flex;
+    justify-content: space-between;
+    margin-top: calc(var(--base) * 2.5);
+    margin-bottom: var(--base);
+
+    @include mid-break {
+      margin-top: calc(var(--base) * 1.5);
+    }
+  }
+
+  &__header-text {
+    margin: 0;
+  }
+
+  &__header-close {
+    border: 0;
+    background-color: transparent;
+    padding: 0;
+    cursor: pointer;
+    overflow: hidden;
+    width: var(--base);
+    height: var(--base);
+
+    svg {
+      width: calc(var(--base) * 2.75);
+      height: calc(var(--base) * 2.75);
+      position: relative;
+      left: calc(var(--base) * -0.825);
+      top: calc(var(--base) * -0.825);
+
+      .stroke {
+        stroke-width: 2px;
+        vector-effect: non-scaling-stroke;
+      }
+    }
+  }
+}

package/dist/field/features/link/drawer/types.d.ts

@@ -0,0 +1,8 @@
+import type { FormState } from 'payload/types';
+import type { LinkPayload } from '../plugins/floatingLinkEditor/types';
+export interface Props {
+    drawerSlug: string;
+    handleModalSubmit: (fields: FormState, data: Record<string, unknown>) => void;
+    stateData?: LinkPayload;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/field/features/link/drawer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/link/drawer/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA;AAEtE,MAAM,WAAW,KAAK;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAC7E,SAAS,CAAC,EAAE,WAAW,CAAA;CACxB"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/feature.client.tsx"],"names":[],"mappings":";AAMA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAA;AAerE,MAAM,MAAM,WAAW,GAAG,6BAA6B,CAAA;AAuEvD,eAAO,MAAM,0BAA0B,4FAA2C,CAAA"}