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

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

@@ -0,0 +1,118 @@
+import { extractTranslations } from 'payload/utilities';
+import { validateUrl } from '../../../lexical/utils/url';
+const translations = extractTranslations([
+    'fields:textToDisplay',
+    'fields:linkType',
+    'fields:chooseBetweenCustomTextOrDocument',
+    'fields:customURL',
+    'fields:internalLink',
+    'fields:enterURL',
+    'fields:chooseDocumentToLink',
+    'fields:openInNewTab'
+]);
+export 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 && !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":["extractTranslations","validateUrl","translations","getBaseFields","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","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,83 @@
+import { Drawer, FieldPathProvider, Form, FormSubmit, RenderFields, getFormState, useConfig, useDocumentInfo, useTranslation } from '@payloadcms/ui';
+import { useFieldPath } from '@payloadcms/ui';
+import React, { useCallback, useEffect, useState } from 'react';
+import { v4 as uuid } from 'uuid';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider';
+import './index.scss';
+const baseClass = 'lexical-link-edit-drawer';
+export const LinkDrawer = ({ drawerSlug, handleModalSubmit, stateData })=>{
+    const { t } = useTranslation();
+    const { id } = useDocumentInfo();
+    const { schemaPath } = useFieldPath();
+    const config = useConfig();
+    const [initialState, setInitialState] = useState(false);
+    const { field: { richTextComponentMap } } = useEditorConfigContext();
+    const componentMapRenderedFieldsPath = `feature.link.fields.fields`;
+    const schemaFieldsPath = `${schemaPath}.feature.link.fields`;
+    const fieldMap = richTextComponentMap.get(componentMapRenderedFieldsPath) // Field Schema
+    ;
+    useEffect(()=>{
+        const awaitInitialState = async ()=>{
+            const state = await 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 = useCallback(async ({ formState: prevFormState })=>{
+        return await 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.createElement(Drawer, {
+        className: baseClass,
+        slug: drawerSlug,
+        title: t('fields:editLink') ?? ''
+    }, initialState !== false && /*#__PURE__*/ React.createElement(FieldPathProvider, {
+        path: "",
+        schemaPath: ""
+    }, /*#__PURE__*/ React.createElement(Form, {
+        // @ts-expect-error // TODO: Fix this type. Is this correct?
+        fields: Array.isArray(fieldMap) ? fieldMap : [],
+        initialState: initialState,
+        onChange: [
+            onChange
+        ],
+        onSubmit: handleModalSubmit,
+        uuid: uuid()
+    }, /*#__PURE__*/ React.createElement(RenderFields, {
+        fieldMap: Array.isArray(fieldMap) ? fieldMap : [],
+        forceRender: true
+    }), /*#__PURE__*/ React.createElement(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/drawer/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saW5rL2RyYXdlci90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEZvcm1TdGF0ZSB9IGZyb20gJ3BheWxvYWQvdHlwZXMnXG5cbmltcG9ydCB0eXBlIHsgTGlua1BheWxvYWQgfSBmcm9tICcuLi9wbHVnaW5zL2Zsb2F0aW5nTGlua0VkaXRvci90eXBlcydcblxuZXhwb3J0IGludGVyZmFjZSBQcm9wcyB7XG4gIGRyYXdlclNsdWc6IHN0cmluZ1xuICBoYW5kbGVNb2RhbFN1Ym1pdDogKGZpZWxkczogRm9ybVN0YXRlLCBkYXRhOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPikgPT4gdm9pZFxuICBzdGF0ZURhdGE/OiBMaW5rUGF5bG9hZFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLFdBSUMifQ==

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"}

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

@@ -0,0 +1,88 @@
+'use client';
+import { $findMatchingParent } from '@lexical/utils';
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { LinkIcon } from '../../lexical/ui/icons/Link';
+import { getSelectedNode } from '../../lexical/utils/getSelectedNode';
+import { FeaturesSectionWithEntries } from '../common/floatingSelectToolbarFeaturesButtonsSection';
+import { createClientComponent } from '../createClientComponent';
+import { AutoLinkNode } from './nodes/AutoLinkNode';
+import { $isLinkNode, LinkNode, TOGGLE_LINK_COMMAND } from './nodes/LinkNode';
+import { AutoLinkPlugin } from './plugins/autoLink';
+import { ClickableLinkPlugin } from './plugins/clickableLink';
+import { FloatingLinkEditorPlugin } from './plugins/floatingLinkEditor';
+import { TOGGLE_LINK_WITH_MODAL_COMMAND } from './plugins/floatingLinkEditor/LinkEditor/commands';
+import { LinkPlugin } from './plugins/link';
+const LinkFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                floatingSelectToolbar: {
+                    sections: [
+                        FeaturesSectionWithEntries([
+                            {
+                                ChildComponent: LinkIcon,
+                                isActive: ({ selection })=>{
+                                    if ($isRangeSelection(selection)) {
+                                        const selectedNode = getSelectedNode(selection);
+                                        const linkParent = $findMatchingParent(selectedNode, $isLinkNode);
+                                        return linkParent != null;
+                                    }
+                                    return false;
+                                },
+                                key: 'link',
+                                label: `Link`,
+                                onClick: ({ editor, isActive })=>{
+                                    if (!isActive) {
+                                        let selectedText = null;
+                                        editor.getEditorState().read(()=>{
+                                            selectedText = $getSelection().getTextContent();
+                                        });
+                                        const linkFields = {
+                                            doc: null,
+                                            linkType: 'custom',
+                                            newTab: false,
+                                            url: 'https://'
+                                        };
+                                        editor.dispatchCommand(TOGGLE_LINK_WITH_MODAL_COMMAND, {
+                                            fields: linkFields,
+                                            text: selectedText
+                                        });
+                                    } else {
+                                        // remove link
+                                        editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+                                    }
+                                },
+                                order: 1
+                            }
+                        ])
+                    ]
+                },
+                nodes: [
+                    LinkNode,
+                    AutoLinkNode
+                ],
+                plugins: [
+                    {
+                        Component: LinkPlugin,
+                        position: 'normal'
+                    },
+                    {
+                        Component: AutoLinkPlugin,
+                        position: 'normal'
+                    },
+                    {
+                        Component: ClickableLinkPlugin,
+                        position: 'normal'
+                    },
+                    {
+                        Component: FloatingLinkEditorPlugin,
+                        position: 'floatingAnchorElem'
+                    }
+                ]
+            })
+    };
+};
+export const LinkFeatureClientComponent = createClientComponent(LinkFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import type { I18n } from '@payloadcms/translations';
+import type { SanitizedConfig } from 'payload/config';
+import type { Field } from 'payload/types';
+import type { FeatureProviderProviderServer } from '../types';
+import type { ClientProps } from './feature.client';
+export type ExclusiveLinkCollectionsProps = {
+    /**
+     * The collections that should be disabled for internal linking. Overrides the `enableRichTextLink` 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 for internal linking. Overrides the `enableRichTextLink` property in the collection config
+     * When this property is set, `disabledCollections` will not be available.
+     **/
+    enabledCollections?: string[];
+};
+export type LinkFeatureServerProps = ExclusiveLinkCollectionsProps & {
+    /**
+     * A function or array defining additional fields for the link feature. These will be
+     * displayed in the link editor drawer.
+     */
+    fields?: ((args: {
+        config: SanitizedConfig;
+        defaultFields: Field[];
+        i18n: I18n;
+    }) => Field[]) | Field[];
+};
+export declare const LinkFeature: FeatureProviderProviderServer<LinkFeatureServerProps, ClientProps>;
+//# sourceMappingURL=feature.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/link/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAM1C,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAUnD,MAAM,MAAM,6BAA6B,GACrC;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,MAAM,MAAM,sBAAsB,GAAG,6BAA6B,GAAG;IACnE;;;OAGG;IACH,MAAM,CAAC,EACH,CAAC,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,eAAe,CAAC;QAAC,aAAa,EAAE,KAAK,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,KAAK,EAAE,CAAC,GACpF,KAAK,EAAE,CAAA;CACZ,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,6BAA6B,CAAC,sBAAsB,EAAE,WAAW,CAgG1F,CAAA"}

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

@@ -0,0 +1,98 @@
+import { initI18n } from '@payloadcms/translations';
+import { translations } from '@payloadcms/translations/client';
+import { convertLexicalNodesToHTML } from '../converters/html/converter';
+import { LinkFeatureClientComponent } from './feature.client';
+import { AutoLinkNode } from './nodes/AutoLinkNode';
+import { LinkNode } from './nodes/LinkNode';
+import { transformExtraFields } from './plugins/floatingLinkEditor/utilities';
+import { linkPopulationPromiseHOC } from './populationPromise';
+export const LinkFeature = (props)=>{
+    if (!props) {
+        props = {};
+    }
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: LinkFeatureClientComponent,
+                clientFeatureProps: {
+                    disabledCollections: props.disabledCollections,
+                    enabledCollections: props.enabledCollections
+                },
+                generateSchemaMap: ({ config, props })=>{
+                    const i18n = initI18n({
+                        config: config.i18n,
+                        context: 'client',
+                        translations
+                    });
+                    return {
+                        fields: transformExtraFields(props.fields, config, i18n, props.enabledCollections, props.disabledCollections)
+                    };
+                },
+                nodes: [
+                    {
+                        converters: {
+                            html: {
+                                converter: async ({ converters, node, parent, payload })=>{
+                                    const childrenText = await convertLexicalNodesToHTML({
+                                        converters,
+                                        lexicalNodes: node.children,
+                                        parent: {
+                                            ...node,
+                                            parent
+                                        },
+                                        payload
+                                    });
+                                    const rel = node.fields.newTab ? ' rel="noopener noreferrer"' : '';
+                                    let href = node.fields.url;
+                                    if (node.fields.linkType === 'internal') {
+                                        href = typeof node.fields.doc?.value === 'string' ? node.fields.doc?.value : node.fields.doc?.value?.id;
+                                    }
+                                    return `<a href="${href}"${rel}>${childrenText}</a>`;
+                                },
+                                nodeTypes: [
+                                    AutoLinkNode.getType()
+                                ]
+                            }
+                        },
+                        node: AutoLinkNode,
+                        populationPromises: [
+                            linkPopulationPromiseHOC(props)
+                        ]
+                    },
+                    {
+                        converters: {
+                            html: {
+                                converter: async ({ converters, node, parent, payload })=>{
+                                    const childrenText = await convertLexicalNodesToHTML({
+                                        converters,
+                                        lexicalNodes: node.children,
+                                        parent: {
+                                            ...node,
+                                            parent
+                                        },
+                                        payload
+                                    });
+                                    const rel = node.fields.newTab ? ' rel="noopener noreferrer"' : '';
+                                    const href = node.fields.linkType === 'custom' ? node.fields.url : node.fields.doc?.value;
+                                    return `<a href="${href}"${rel}>${childrenText}</a>`;
+                                },
+                                nodeTypes: [
+                                    LinkNode.getType()
+                                ]
+                            }
+                        },
+                        node: LinkNode,
+                        populationPromises: [
+                            linkPopulationPromiseHOC(props)
+                        ]
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'link',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/field/features/link/feature.server.ts"],"sourcesContent":["import type { I18n } from '@payloadcms/translations'\nimport type { SanitizedConfig } from 'payload/config'\nimport type { Field } from 'payload/types'\n\nimport { initI18n } from '@payloadcms/translations'\nimport { translations } from '@payloadcms/translations/client'\n\nimport type { HTMLConverter } from '../converters/html/converter/types'\nimport type { FeatureProviderProviderServer } from '../types'\nimport type { ClientProps } from './feature.client'\nimport type { SerializedAutoLinkNode, SerializedLinkNode } from './nodes/types'\n\nimport { convertLexicalNodesToHTML } from '../converters/html/converter'\nimport { LinkFeatureClientComponent } from './feature.client'\nimport { AutoLinkNode } from './nodes/AutoLinkNode'\nimport { LinkNode } from './nodes/LinkNode'\nimport { transformExtraFields } from './plugins/floatingLinkEditor/utilities'\nimport { linkPopulationPromiseHOC } from './populationPromise'\n\nexport type ExclusiveLinkCollectionsProps =\n  | {\n      /**\n       * The collections that should be disabled for internal linking. Overrides the `enableRichTextLink` property in the collection config.\n       * When this property is set, `enabledCollections` will not be available.\n       **/\n      disabledCollections?: string[]\n\n      // Ensures that enabledCollections is not available when disabledCollections is set\n      enabledCollections?: never\n    }\n  | {\n      // Ensures that disabledCollections is not available when enabledCollections is set\n      disabledCollections?: never\n\n      /**\n       * The collections that should be enabled for internal linking. Overrides the `enableRichTextLink` property in the collection config\n       * When this property is set, `disabledCollections` will not be available.\n       **/\n      enabledCollections?: string[]\n    }\n\nexport type LinkFeatureServerProps = ExclusiveLinkCollectionsProps & {\n  /**\n   * A function or array defining additional fields for the link feature. These will be\n   * displayed in the link editor drawer.\n   */\n  fields?:\n    | ((args: { config: SanitizedConfig; defaultFields: Field[]; i18n: I18n }) => Field[])\n    | Field[]\n}\n\nexport const LinkFeature: FeatureProviderProviderServer<LinkFeatureServerProps, ClientProps> = (\n  props,\n) => {\n  if (!props) {\n    props = {}\n  }\n  return {\n    feature: () => {\n      return {\n        ClientComponent: LinkFeatureClientComponent,\n        clientFeatureProps: {\n          disabledCollections: props.disabledCollections,\n          enabledCollections: props.enabledCollections,\n        } as ExclusiveLinkCollectionsProps,\n        generateSchemaMap: ({ config, props }) => {\n          const i18n = initI18n({ config: config.i18n, context: 'client', translations })\n\n          return {\n            fields: transformExtraFields(\n              props.fields,\n              config,\n              i18n,\n              props.enabledCollections,\n              props.disabledCollections,\n            ),\n          }\n        },\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: async ({ converters, node, parent, payload }) => {\n                  const childrenText = await convertLexicalNodesToHTML({\n                    converters,\n                    lexicalNodes: node.children,\n                    parent: {\n                      ...node,\n                      parent,\n                    },\n                    payload,\n                  })\n\n                  const rel: string = node.fields.newTab ? ' rel=\"noopener noreferrer\"' : ''\n\n                  let href: string = node.fields.url\n                  if (node.fields.linkType === 'internal') {\n                    href =\n                      typeof node.fields.doc?.value === 'string'\n                        ? node.fields.doc?.value\n                        : node.fields.doc?.value?.id\n                  }\n\n                  return `<a href=\"${href}\"${rel}>${childrenText}</a>`\n                },\n                nodeTypes: [AutoLinkNode.getType()],\n              } as HTMLConverter<SerializedAutoLinkNode>,\n            },\n            node: AutoLinkNode,\n            populationPromises: [linkPopulationPromiseHOC(props)],\n          },\n          {\n            converters: {\n              html: {\n                converter: async ({ converters, node, parent, payload }) => {\n                  const childrenText = await convertLexicalNodesToHTML({\n                    converters,\n                    lexicalNodes: node.children,\n                    parent: {\n                      ...node,\n                      parent,\n                    },\n                    payload,\n                  })\n\n                  const rel: string = node.fields.newTab ? ' rel=\"noopener noreferrer\"' : ''\n\n                  const href: string =\n                    node.fields.linkType === 'custom'\n                      ? node.fields.url\n                      : (node.fields.doc?.value as string)\n\n                  return `<a href=\"${href}\"${rel}>${childrenText}</a>`\n                },\n                nodeTypes: [LinkNode.getType()],\n              } as HTMLConverter<SerializedLinkNode>,\n            },\n            node: LinkNode,\n            populationPromises: [linkPopulationPromiseHOC(props)],\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'link',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["initI18n","translations","convertLexicalNodesToHTML","LinkFeatureClientComponent","AutoLinkNode","LinkNode","transformExtraFields","linkPopulationPromiseHOC","LinkFeature","props","feature","ClientComponent","clientFeatureProps","disabledCollections","enabledCollections","generateSchemaMap","config","i18n","context","fields","nodes","converters","html","converter","node","parent","payload","childrenText","lexicalNodes","children","rel","newTab","href","url","linkType","doc","value","id","nodeTypes","getType","populationPromises","serverFeatureProps","key"],"mappings":"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"}

package/dist/field/features/link/nodes/AutoLinkNode.d.ts

@@ -0,0 +1,16 @@
+import { type ElementNode, type LexicalNode, type RangeSelection } from 'lexical';
+import type { LinkFields, SerializedAutoLinkNode } from './types';
+import { LinkNode } from './LinkNode';
+export declare class AutoLinkNode extends LinkNode {
+    static clone(node: AutoLinkNode): AutoLinkNode;
+    static getType(): string;
+    static importDOM(): null;
+    static importJSON(serializedNode: SerializedAutoLinkNode): AutoLinkNode;
+    exportJSON(): SerializedAutoLinkNode;
+    insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): ElementNode | null;
+}
+export declare function $createAutoLinkNode({ fields }: {
+    fields: LinkFields;
+}): AutoLinkNode;
+export declare function $isAutoLinkNode(node: LexicalNode | null | undefined): node is AutoLinkNode;
+//# sourceMappingURL=AutoLinkNode.d.ts.map

package/dist/field/features/link/nodes/AutoLinkNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoLinkNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/link/nodes/AutoLinkNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAEjE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAKrC,qBAAa,YAAa,SAAQ,QAAQ;IACxC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY;IAI9C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,IAAI;IAKxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,sBAAsB,GAAG,YAAY;IAkBvE,UAAU,IAAI,sBAAsB;IAQpC,cAAc,CAAC,SAAS,EAAE,cAAc,EAAE,gBAAgB,UAAO,GAAG,WAAW,GAAG,IAAI;CASvF;AAED,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,GAAG,YAAY,CAEpF;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,YAAY,CAE1F"}