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

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

@@ -0,0 +1,103 @@
+import { UploadFeatureClientComponent } from './feature.client';
+import { UploadNode } from './nodes/UploadNode';
+import { uploadPopulationPromiseHOC } from './populationPromise';
+import { uploadValidation } from './validate';
+/**
+ * Get the absolute URL for an upload URL by potentially prepending the serverURL
+ */ function getAbsoluteURL(url, payload) {
+    return url?.startsWith('http') ? url : (payload?.config?.serverURL || '') + url;
+}
+export const UploadFeature = (props)=>{
+    if (!props) {
+        props = {
+            collections: {}
+        };
+    }
+    const clientProps = {
+        collections: {}
+    };
+    if (props.collections) {
+        for(const collection in props.collections){
+            clientProps.collections[collection] = {
+                hasExtraFields: props.collections[collection].fields.length >= 1
+            };
+        }
+    }
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: UploadFeatureClientComponent,
+                clientFeatureProps: clientProps,
+                generateSchemaMap: ({ props })=>{
+                    if (!props?.collections) return {};
+                    const map = {};
+                    for(const collection in props.collections){
+                        map[collection] = props.collections[collection].fields;
+                    }
+                    return map;
+                },
+                nodes: [
+                    {
+                        converters: {
+                            html: {
+                                converter: async ({ node, payload })=>{
+                                    if (payload) {
+                                        const uploadDocument = await payload.findByID({
+                                            id: node.value.id,
+                                            collection: node.relationTo
+                                        });
+                                        const url = getAbsoluteURL(uploadDocument?.url, payload);
+                                        /**
+                     * If the upload is not an image, return a link to the upload
+                     */ if (!uploadDocument?.mimeType?.startsWith('image')) {
+                                            return `<a href="${url}" rel="noopener noreferrer">${uploadDocument.filename}</a>`;
+                                        }
+                                        /**
+                     * If the upload is a simple image with no different sizes, return a simple img tag
+                     */ if (!uploadDocument?.sizes || !Object.keys(uploadDocument?.sizes).length) {
+                                            return `<img src="${url}" alt="${uploadDocument?.filename}" width="${uploadDocument?.width}"  height="${uploadDocument?.height}"/>`;
+                                        }
+                                        /**
+                     * If the upload is an image with different sizes, return a picture element
+                     */ let pictureHTML = '<picture>';
+                                        // Iterate through each size in the data.sizes object
+                                        for(const size in uploadDocument.sizes){
+                                            const imageSize = uploadDocument.sizes[size];
+                                            // Skip if any property of the size object is null
+                                            if (!imageSize.width || !imageSize.height || !imageSize.mimeType || !imageSize.filesize || !imageSize.filename || !imageSize.url) {
+                                                continue;
+                                            }
+                                            const imageSizeURL = getAbsoluteURL(imageSize?.url, payload);
+                                            pictureHTML += `<source srcset="${imageSizeURL}" media="(max-width: ${imageSize.width}px)" type="${imageSize.mimeType}">`;
+                                        }
+                                        // Add the default img tag
+                                        pictureHTML += `<img src="${url}" alt="Image" width="${uploadDocument.width}" height="${uploadDocument.height}">`;
+                                        pictureHTML += '</picture>';
+                                        return pictureHTML;
+                                    } else {
+                                        return `<img src="${node.value.id}" />`;
+                                    }
+                                },
+                                nodeTypes: [
+                                    UploadNode.getType()
+                                ]
+                            }
+                        },
+                        node: UploadNode,
+                        populationPromises: [
+                            uploadPopulationPromiseHOC(props)
+                        ],
+                        validations: [
+                            uploadValidation()
+                        ]
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'upload',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/field/features/upload/feature.server.ts"],"sourcesContent":["import type { Field, Payload } from 'payload/types'\n\nimport type { HTMLConverter } from '../converters/html/converter/types'\nimport type { FeatureProviderProviderServer } from '../types'\nimport type { UploadFeaturePropsClient } from './feature.client'\n\nimport { UploadFeatureClientComponent } from './feature.client'\nimport { type SerializedUploadNode, UploadNode } from './nodes/UploadNode'\nimport { uploadPopulationPromiseHOC } from './populationPromise'\nimport { uploadValidation } from './validate'\n\nexport type UploadFeatureProps = {\n  collections: {\n    [collection: string]: {\n      fields: Field[]\n    }\n  }\n}\n\n/**\n * Get the absolute URL for an upload URL by potentially prepending the serverURL\n */\nfunction getAbsoluteURL(url: string, payload: Payload): string {\n  return url?.startsWith('http') ? url : (payload?.config?.serverURL || '') + url\n}\n\nexport const UploadFeature: FeatureProviderProviderServer<\n  UploadFeatureProps,\n  UploadFeaturePropsClient\n> = (props) => {\n  if (!props) {\n    props = { collections: {} }\n  }\n\n  const clientProps: UploadFeaturePropsClient = { collections: {} }\n  if (props.collections) {\n    for (const collection in props.collections) {\n      clientProps.collections[collection] = {\n        hasExtraFields: props.collections[collection].fields.length >= 1,\n      }\n    }\n  }\n\n  return {\n    feature: () => {\n      return {\n        ClientComponent: UploadFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ props }) => {\n          if (!props?.collections) return {}\n\n          const map: {\n            [key: string]: Field[]\n          } = {}\n\n          for (const collection in props.collections) {\n            map[collection] = props.collections[collection].fields\n          }\n\n          return map\n        },\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: async ({ node, payload }) => {\n                  if (payload) {\n                    const uploadDocument: any = await payload.findByID({\n                      id: node.value.id,\n                      collection: node.relationTo,\n                    })\n\n                    const url: string = getAbsoluteURL(uploadDocument?.url as string, payload)\n\n                    /**\n                     * If the upload is not an image, return a link to the upload\n                     */\n                    if (!(uploadDocument?.mimeType as string)?.startsWith('image')) {\n                      return `<a href=\"${url}\" rel=\"noopener noreferrer\">${uploadDocument.filename}</a>`\n                    }\n\n                    /**\n                     * If the upload is a simple image with no different sizes, return a simple img tag\n                     */\n                    if (!uploadDocument?.sizes || !Object.keys(uploadDocument?.sizes).length) {\n                      return `<img src=\"${url}\" alt=\"${uploadDocument?.filename}\" width=\"${uploadDocument?.width}\"  height=\"${uploadDocument?.height}\"/>`\n                    }\n\n                    /**\n                     * If the upload is an image with different sizes, return a picture element\n                     */\n                    let pictureHTML = '<picture>'\n\n                    // Iterate through each size in the data.sizes object\n                    for (const size in uploadDocument.sizes) {\n                      const imageSize = uploadDocument.sizes[size]\n\n                      // Skip if any property of the size object is null\n                      if (\n                        !imageSize.width ||\n                        !imageSize.height ||\n                        !imageSize.mimeType ||\n                        !imageSize.filesize ||\n                        !imageSize.filename ||\n                        !imageSize.url\n                      ) {\n                        continue\n                      }\n                      const imageSizeURL: string = getAbsoluteURL(imageSize?.url as string, payload)\n\n                      pictureHTML += `<source srcset=\"${imageSizeURL}\" media=\"(max-width: ${imageSize.width}px)\" type=\"${imageSize.mimeType}\">`\n                    }\n\n                    // Add the default img tag\n                    pictureHTML += `<img src=\"${url}\" alt=\"Image\" width=\"${uploadDocument.width}\" height=\"${uploadDocument.height}\">`\n                    pictureHTML += '</picture>'\n                    return pictureHTML\n                  } else {\n                    return `<img src=\"${node.value.id}\" />`\n                  }\n                },\n                nodeTypes: [UploadNode.getType()],\n              } as HTMLConverter<SerializedUploadNode>,\n            },\n            node: UploadNode,\n            populationPromises: [uploadPopulationPromiseHOC(props)],\n            validations: [uploadValidation()],\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'upload',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["UploadFeatureClientComponent","UploadNode","uploadPopulationPromiseHOC","uploadValidation","getAbsoluteURL","url","payload","startsWith","config","serverURL","UploadFeature","props","collections","clientProps","collection","hasExtraFields","fields","length","feature","ClientComponent","clientFeatureProps","generateSchemaMap","map","nodes","converters","html","converter","node","uploadDocument","findByID","id","value","relationTo","mimeType","filename","sizes","Object","keys","width","height","pictureHTML","size","imageSize","filesize","imageSizeURL","nodeTypes","getType","populationPromises","validations","serverFeatureProps","key"],"mappings":"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"}

package/dist/field/features/upload/nodes/UploadNode.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="react" />
+import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import type { ElementFormatType, NodeKey } from 'lexical';
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import { type DOMConversionMap, type DOMExportOutput, type LexicalNode, type Spread } from 'lexical';
+export type RawUploadPayload = {
+    fields: {
+        [key: string]: unknown;
+    };
+    id: string;
+    relationTo: string;
+};
+export type UploadData = {
+    fields: {
+        [key: string]: unknown;
+    };
+    relationTo: string;
+    value: {
+        [key: string]: unknown;
+        id: string;
+    };
+};
+export type SerializedUploadNode = Spread<UploadData, SerializedDecoratorBlockNode>;
+export declare class UploadNode extends DecoratorBlockNode {
+    __data: UploadData;
+    constructor({ data, format, key, }: {
+        data: UploadData;
+        format?: ElementFormatType;
+        key?: NodeKey;
+    });
+    static clone(node: UploadNode): UploadNode;
+    static getType(): string;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedUploadNode): UploadNode;
+    static isInline(): false;
+    decorate(): JSX.Element;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedUploadNode;
+    getData(): UploadData;
+    setData(data: UploadData): void;
+    updateDOM(): false;
+}
+export declare function $createUploadNode({ data }: {
+    data: UploadData;
+}): UploadNode;
+export declare function $isUploadNode(node: LexicalNode | null | undefined): node is UploadNode;
+//# sourceMappingURL=UploadNode.d.ts.map

package/dist/field/features/upload/nodes/UploadNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploadNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/nodes/UploadNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAA;AAC7E,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,MAAM,EACZ,MAAM,SAAS,CAAA;AAMhB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE;QAEN,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;IACD,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE;QAEN,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE;QAEL,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;QACtB,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF,CAAA;AAYD,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,UAAU,EAAE,4BAA4B,CAAC,CAAA;AAEnF,qBAAa,UAAW,SAAQ,kBAAkB;IAChD,MAAM,EAAE,UAAU,CAAA;gBAEN,EACV,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;QACD,IAAI,EAAE,UAAU,CAAA;QAChB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IAQ1C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,oBAAoB,GAAG,UAAU;IAanE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAIxB,QAAQ,IAAI,GAAG,CAAC,OAAO;IAIvB,SAAS,IAAI,eAAe;IAO5B,UAAU,IAAI,oBAAoB;IASlC,OAAO,IAAI,UAAU;IAIrB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM/B,SAAS,IAAI,KAAK;CAGnB;AAED,wBAAgB,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,UAAU,CAE5E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,UAAU,CAEtF"}

package/dist/field/features/upload/nodes/UploadNode.js

@@ -0,0 +1,98 @@
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import { $applyNodeReplacement } from 'lexical';
+import * as React from 'react';
+// @ts-expect-error-next-line TypeScript being dumb
+const RawUploadComponent = /*#__PURE__*/ React.lazy(async ()=>await import('../component'));
+function convertUploadElement(domNode) {
+    if (domNode instanceof HTMLImageElement) {
+    // const { alt: altText, src } = domNode;
+    // const node = $createImageNode({ altText, src });
+    // return { node };
+    // TODO: Auto-upload functionality here!
+    }
+    return null;
+}
+export class UploadNode extends DecoratorBlockNode {
+    __data;
+    constructor({ data, format, key }){
+        super(format, key);
+        this.__data = data;
+    }
+    static clone(node) {
+        return new UploadNode({
+            data: node.__data,
+            format: node.__format,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'upload';
+    }
+    static importDOM() {
+        return {
+            img: (node)=>({
+                    conversion: convertUploadElement,
+                    priority: 0
+                })
+        };
+    }
+    static importJSON(serializedNode) {
+        const importedData = {
+            fields: serializedNode.fields,
+            relationTo: serializedNode.relationTo,
+            value: serializedNode.value
+        };
+        const node = $createUploadNode({
+            data: importedData
+        });
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate() {
+        return /*#__PURE__*/ React.createElement(RawUploadComponent, {
+            data: this.__data,
+            format: this.__format,
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('img');
+        // element.setAttribute('src', this.__src);
+        // element.setAttribute('alt', this.__altText); //TODO
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            ...this.getData(),
+            type: this.getType(),
+            version: 1
+        };
+    }
+    getData() {
+        return this.getLatest().__data;
+    }
+    setData(data) {
+        const writable = this.getWritable();
+        writable.__data = data;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    updateDOM() {
+        return false;
+    }
+}
+export function $createUploadNode({ data }) {
+    return $applyNodeReplacement(new UploadNode({
+        data
+    }));
+}
+export function $isUploadNode(node) {
+    return node instanceof UploadNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/upload/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/plugin/index.tsx"],"names":[],"mappings":";AAIA,OAAO,EAML,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAK3D,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAA;AAE5D,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,mBAAmB,CAC9B,CAAA;AAExC,wBAAgB,YAAY,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAuDjD"}

package/dist/field/features/upload/plugin/index.js

@@ -0,0 +1,52 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils';
+import { useConfig } from '@payloadcms/ui';
+import { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import React, { useEffect } from 'react';
+import { UploadDrawer } from '../drawer';
+import { $createUploadNode, UploadNode } from '../nodes/UploadNode';
+export const INSERT_UPLOAD_COMMAND = createCommand('INSERT_UPLOAD_COMMAND');
+export function UploadPlugin() {
+    const [editor] = useLexicalComposerContext();
+    const { collections } = useConfig();
+    useEffect(()=>{
+        if (!editor.hasNodes([
+            UploadNode
+        ])) {
+            throw new Error('UploadPlugin: UploadNode not registered on editor');
+        }
+        return mergeRegister(editor.registerCommand(INSERT_UPLOAD_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const uploadNode = $createUploadNode({
+                    data: {
+                        fields: payload.fields,
+                        relationTo: payload.relationTo,
+                        value: {
+                            id: payload.id
+                        }
+                    }
+                });
+                const selection = $getSelection() || $getPreviousSelection();
+                if ($isRangeSelection(selection)) {
+                    const { focus } = selection;
+                    const focusNode = focus.getNode();
+                    // First, delete currently selected node if it's an empty paragraph and if there are sufficient
+                    // paragraph nodes (more than 1) left in the parent node, so that we don't "trap" the user
+                    if ($isParagraphNode(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParent().getChildren().filter((node)=>$isParagraphNode(node)).length > 1) {
+                        focusNode.remove();
+                    }
+                    $insertNodeToNearestRoot(uploadNode);
+                }
+            });
+            return true;
+        }, COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ React.createElement(UploadDrawer, {
+        enabledCollectionSlugs: collections.map(({ slug })=>slug)
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy91cGxvYWQvcGx1Z2luL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCB7IHVzZUxleGljYWxDb21wb3NlckNvbnRleHQgfSBmcm9tICdAbGV4aWNhbC9yZWFjdC9MZXhpY2FsQ29tcG9zZXJDb250ZXh0J1xuaW1wb3J0IHsgJGluc2VydE5vZGVUb05lYXJlc3RSb290LCBtZXJnZVJlZ2lzdGVyIH0gZnJvbSAnQGxleGljYWwvdXRpbHMnXG5pbXBvcnQgeyB1c2VDb25maWcgfSBmcm9tICdAcGF5bG9hZGNtcy91aSdcbmltcG9ydCB7XG4gICRnZXRQcmV2aW91c1NlbGVjdGlvbixcbiAgJGdldFNlbGVjdGlvbixcbiAgJGlzUGFyYWdyYXBoTm9kZSxcbiAgJGlzUmFuZ2VTZWxlY3Rpb24sXG4gIENPTU1BTkRfUFJJT1JJVFlfRURJVE9SLFxuICB0eXBlIExleGljYWxDb21tYW5kLFxuICBjcmVhdGVDb21tYW5kLFxufSBmcm9tICdsZXhpY2FsJ1xuaW1wb3J0IFJlYWN0LCB7IHVzZUVmZmVjdCB9IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgdHlwZSB7IFJhd1VwbG9hZFBheWxvYWQgfSBmcm9tICcuLi9ub2Rlcy9VcGxvYWROb2RlJ1xuXG5pbXBvcnQgeyBVcGxvYWREcmF3ZXIgfSBmcm9tICcuLi9kcmF3ZXInXG5pbXBvcnQgeyAkY3JlYXRlVXBsb2FkTm9kZSwgVXBsb2FkTm9kZSB9IGZyb20gJy4uL25vZGVzL1VwbG9hZE5vZGUnXG5cbmV4cG9ydCB0eXBlIEluc2VydFVwbG9hZFBheWxvYWQgPSBSZWFkb25seTxSYXdVcGxvYWRQYXlsb2FkPlxuXG5leHBvcnQgY29uc3QgSU5TRVJUX1VQTE9BRF9DT01NQU5EOiBMZXhpY2FsQ29tbWFuZDxJbnNlcnRVcGxvYWRQYXlsb2FkPiA9XG4gIGNyZWF0ZUNvbW1hbmQoJ0lOU0VSVF9VUExPQURfQ09NTUFORCcpXG5cbmV4cG9ydCBmdW5jdGlvbiBVcGxvYWRQbHVnaW4oKTogSlNYLkVsZW1lbnQgfCBudWxsIHtcbiAgY29uc3QgW2VkaXRvcl0gPSB1c2VMZXhpY2FsQ29tcG9zZXJDb250ZXh0KClcbiAgY29uc3QgeyBjb2xsZWN0aW9ucyB9ID0gdXNlQ29uZmlnKClcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGlmICghZWRpdG9yLmhhc05vZGVzKFtVcGxvYWROb2RlXSkpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignVXBsb2FkUGx1Z2luOiBVcGxvYWROb2RlIG5vdCByZWdpc3RlcmVkIG9uIGVkaXRvcicpXG4gICAgfVxuXG4gICAgcmV0dXJuIG1lcmdlUmVnaXN0ZXIoXG4gICAgICBlZGl0b3IucmVnaXN0ZXJDb21tYW5kPEluc2VydFVwbG9hZFBheWxvYWQ+KFxuICAgICAgICBJTlNFUlRfVVBMT0FEX0NPTU1BTkQsXG4gICAgICAgIChwYXlsb2FkOiBJbnNlcnRVcGxvYWRQYXlsb2FkKSA9PiB7XG4gICAgICAgICAgZWRpdG9yLnVwZGF0ZSgoKSA9PiB7XG4gICAgICAgICAgICBjb25zdCB1cGxvYWROb2RlID0gJGNyZWF0ZVVwbG9hZE5vZGUoe1xuICAgICAgICAgICAgICBkYXRhOiB7XG4gICAgICAgICAgICAgICAgZmllbGRzOiBwYXlsb2FkLmZpZWxkcyxcbiAgICAgICAgICAgICAgICByZWxhdGlvblRvOiBwYXlsb2FkLnJlbGF0aW9uVG8sXG4gICAgICAgICAgICAgICAgdmFsdWU6IHtcbiAgICAgICAgICAgICAgICAgIGlkOiBwYXlsb2FkLmlkLFxuICAgICAgICAgICAgICAgIH0sXG4gICAgICAgICAgICAgIH0sXG4gICAgICAgICAgICB9KVxuXG4gICAgICAgICAgICBjb25zdCBzZWxlY3Rpb24gPSAkZ2V0U2VsZWN0aW9uKCkgfHwgJGdldFByZXZpb3VzU2VsZWN0aW9uKClcblxuICAgICAgICAgICAgaWYgKCRpc1JhbmdlU2VsZWN0aW9uKHNlbGVjdGlvbikpIHtcbiAgICAgICAgICAgICAgY29uc3QgeyBmb2N1cyB9ID0gc2VsZWN0aW9uXG4gICAgICAgICAgICAgIGNvbnN0IGZvY3VzTm9kZSA9IGZvY3VzLmdldE5vZGUoKVxuXG4gICAgICAgICAgICAgIC8vIEZpcnN0LCBkZWxldGUgY3VycmVudGx5IHNlbGVjdGVkIG5vZGUgaWYgaXQncyBhbiBlbXB0eSBwYXJhZ3JhcGggYW5kIGlmIHRoZXJlIGFyZSBzdWZmaWNpZW50XG4gICAgICAgICAgICAgIC8vIHBhcmFncmFwaCBub2RlcyAobW9yZSB0aGFuIDEpIGxlZnQgaW4gdGhlIHBhcmVudCBub2RlLCBzbyB0aGF0IHdlIGRvbid0IFwidHJhcFwiIHRoZSB1c2VyXG4gICAgICAgICAgICAgIGlmIChcbiAgICAgICAgICAgICAgICAkaXNQYXJhZ3JhcGhOb2RlKGZvY3VzTm9kZSkgJiZcbiAgICAgICAgICAgICAgICBmb2N1c05vZGUuZ2V0VGV4dENvbnRlbnRTaXplKCkgPT09IDAgJiZcbiAgICAgICAgICAgICAgICBmb2N1c05vZGVcbiAgICAgICAgICAgICAgICAgIC5nZXRQYXJlbnQoKVxuICAgICAgICAgICAgICAgICAgLmdldENoaWxkcmVuKClcbiAgICAgICAgICAgICAgICAgIC5maWx0ZXIoKG5vZGUpID0+ICRpc1BhcmFncmFwaE5vZGUobm9kZSkpLmxlbmd0aCA+IDFcbiAgICAgICAgICAgICAgKSB7XG4gICAgICAgICAgICAgICAgZm9jdXNOb2RlLnJlbW92ZSgpXG4gICAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgICAkaW5zZXJ0Tm9kZVRvTmVhcmVzdFJvb3QodXBsb2FkTm9kZSlcbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9KVxuXG4gICAgICAgICAgcmV0dXJuIHRydWVcbiAgICAgICAgfSxcbiAgICAgICAgQ09NTUFORF9QUklPUklUWV9FRElUT1IsXG4gICAgICApLFxuICAgIClcbiAgfSwgW2VkaXRvcl0pXG5cbiAgcmV0dXJuIDxVcGxvYWREcmF3ZXIgZW5hYmxlZENvbGxlY3Rpb25TbHVncz17Y29sbGVjdGlvbnMubWFwKCh7IHNsdWcgfSkgPT4gc2x1Zyl9IC8+XG59XG4iXSwibmFtZXMiOlsidXNlTGV4aWNhbENvbXBvc2VyQ29udGV4dCIsIiRpbnNlcnROb2RlVG9OZWFyZXN0Um9vdCIsIm1lcmdlUmVnaXN0ZXIiLCJ1c2VDb25maWciLCIkZ2V0UHJldmlvdXNTZWxlY3Rpb24iLCIkZ2V0U2VsZWN0aW9uIiwiJGlzUGFyYWdyYXBoTm9kZSIsIiRpc1JhbmdlU2VsZWN0aW9uIiwiQ09NTUFORF9QUklPUklUWV9FRElUT1IiLCJjcmVhdGVDb21tYW5kIiwiUmVhY3QiLCJ1c2VFZmZlY3QiLCJVcGxvYWREcmF3ZXIiLCIkY3JlYXRlVXBsb2FkTm9kZSIsIlVwbG9hZE5vZGUiLCJJTlNFUlRfVVBMT0FEX0NPTU1BTkQiLCJVcGxvYWRQbHVnaW4iLCJlZGl0b3IiLCJjb2xsZWN0aW9ucyIsImhhc05vZGVzIiwiRXJyb3IiLCJyZWdpc3RlckNvbW1hbmQiLCJwYXlsb2FkIiwidXBkYXRlIiwidXBsb2FkTm9kZSIsImRhdGEiLCJmaWVsZHMiLCJyZWxhdGlvblRvIiwidmFsdWUiLCJpZCIsInNlbGVjdGlvbiIsImZvY3VzIiwiZm9jdXNOb2RlIiwiZ2V0Tm9kZSIsImdldFRleHRDb250ZW50U2l6ZSIsImdldFBhcmVudCIsImdldENoaWxkcmVuIiwiZmlsdGVyIiwibm9kZSIsImxlbmd0aCIsInJlbW92ZSIsImVuYWJsZWRDb2xsZWN0aW9uU2x1Z3MiLCJtYXAiLCJzbHVnIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBLFNBQVNBLHlCQUF5QixRQUFRLHdDQUF1QztBQUNqRixTQUFTQyx3QkFBd0IsRUFBRUMsYUFBYSxRQUFRLGlCQUFnQjtBQUN4RSxTQUFTQyxTQUFTLFFBQVEsaUJBQWdCO0FBQzFDLFNBQ0VDLHFCQUFxQixFQUNyQkMsYUFBYSxFQUNiQyxnQkFBZ0IsRUFDaEJDLGlCQUFpQixFQUNqQkMsdUJBQXVCLEVBRXZCQyxhQUFhLFFBQ1IsVUFBUztBQUNoQixPQUFPQyxTQUFTQyxTQUFTLFFBQVEsUUFBTztBQUl4QyxTQUFTQyxZQUFZLFFBQVEsWUFBVztBQUN4QyxTQUFTQyxpQkFBaUIsRUFBRUMsVUFBVSxRQUFRLHNCQUFxQjtBQUluRSxPQUFPLE1BQU1DLHdCQUNYTixjQUFjLHlCQUF3QjtBQUV4QyxPQUFPLFNBQVNPO0lBQ2QsTUFBTSxDQUFDQyxPQUFPLEdBQUdqQjtJQUNqQixNQUFNLEVBQUVrQixXQUFXLEVBQUUsR0FBR2Y7SUFFeEJRLFVBQVU7UUFDUixJQUFJLENBQUNNLE9BQU9FLFFBQVEsQ0FBQztZQUFDTDtTQUFXLEdBQUc7WUFDbEMsTUFBTSxJQUFJTSxNQUFNO1FBQ2xCO1FBRUEsT0FBT2xCLGNBQ0xlLE9BQU9JLGVBQWUsQ0FDcEJOLHVCQUNBLENBQUNPO1lBQ0NMLE9BQU9NLE1BQU0sQ0FBQztnQkFDWixNQUFNQyxhQUFhWCxrQkFBa0I7b0JBQ25DWSxNQUFNO3dCQUNKQyxRQUFRSixRQUFRSSxNQUFNO3dCQUN0QkMsWUFBWUwsUUFBUUssVUFBVTt3QkFDOUJDLE9BQU87NEJBQ0xDLElBQUlQLFFBQVFPLEVBQUU7d0JBQ2hCO29CQUNGO2dCQUNGO2dCQUVBLE1BQU1DLFlBQVl6QixtQkFBbUJEO2dCQUVyQyxJQUFJRyxrQkFBa0J1QixZQUFZO29CQUNoQyxNQUFNLEVBQUVDLEtBQUssRUFBRSxHQUFHRDtvQkFDbEIsTUFBTUUsWUFBWUQsTUFBTUUsT0FBTztvQkFFL0IsK0ZBQStGO29CQUMvRiwwRkFBMEY7b0JBQzFGLElBQ0UzQixpQkFBaUIwQixjQUNqQkEsVUFBVUUsa0JBQWtCLE9BQU8sS0FDbkNGLFVBQ0dHLFNBQVMsR0FDVEMsV0FBVyxHQUNYQyxNQUFNLENBQUMsQ0FBQ0MsT0FBU2hDLGlCQUFpQmdDLE9BQU9DLE1BQU0sR0FBRyxHQUNyRDt3QkFDQVAsVUFBVVEsTUFBTTtvQkFDbEI7b0JBRUF2Qyx5QkFBeUJ1QjtnQkFDM0I7WUFDRjtZQUVBLE9BQU87UUFDVCxHQUNBaEI7SUFHTixHQUFHO1FBQUNTO0tBQU87SUFFWCxxQkFBTyxvQkFBQ0w7UUFBYTZCLHdCQUF3QnZCLFlBQVl3QixHQUFHLENBQUMsQ0FBQyxFQUFFQyxJQUFJLEVBQUUsR0FBS0E7O0FBQzdFIn0=

package/dist/field/features/upload/populationPromise.d.ts

@@ -0,0 +1,5 @@
+import type { UploadFeatureProps } from '@payloadcms/richtext-lexical';
+import type { PopulationPromise } from '../types';
+import type { SerializedUploadNode } from './nodes/UploadNode';
+export declare const uploadPopulationPromiseHOC: (props?: UploadFeatureProps) => PopulationPromise<SerializedUploadNode>;
+//# sourceMappingURL=populationPromise.d.ts.map

package/dist/field/features/upload/populationPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAEtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAK9D,eAAO,MAAM,0BAA0B,WAC7B,kBAAkB,KACzB,kBAAkB,oBAAoB,CA6DxC,CAAA"}

package/dist/field/features/upload/populationPromise.js

@@ -0,0 +1,46 @@
+import { populate } from '../../../populate/populate';
+import { recurseNestedFields } from '../../../populate/recurseNestedFields';
+export const uploadPopulationPromiseHOC = (props)=>{
+    const uploadPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
+        const promises = [];
+        if (node?.value?.id) {
+            const collection = req.payload.collections[node?.relationTo];
+            if (collection) {
+                promises.push(populate({
+                    id: node?.value?.id,
+                    collection,
+                    currentDepth,
+                    data: node,
+                    depth,
+                    field,
+                    key: 'value',
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+            if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {
+                recurseNestedFields({
+                    context,
+                    currentDepth,
+                    data: node.fields || {},
+                    depth,
+                    editorPopulationPromises,
+                    fields: props?.collections?.[node?.relationTo]?.fields,
+                    findMany,
+                    flattenLocales,
+                    overrideAccess,
+                    populationPromises,
+                    promises,
+                    req,
+                    showHiddenFields,
+                    siblingDoc: node.fields || {}
+                });
+            }
+        }
+        return promises;
+    };
+    return uploadPopulationPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/upload/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAI9D,eAAO,MAAM,gBAAgB,QAAO,eAAe,oBAAoB,CA8BtE,CAAA"}

package/dist/field/features/upload/validate.js

@@ -0,0 +1,19 @@
+import { fieldAffectsData } from 'payload/types';
+import { getIDType, isValidID } from 'payload/utilities';
+import { CAN_USE_DOM } from '../../lexical/utils/canUseDOM';
+export const uploadValidation = ()=>{
+    const uploadValidation = ({ node, validation: { options: { req: { payload: { config, db }, t } } } })=>{
+        if (!CAN_USE_DOM) {
+            const idField = config.collections.find(({ slug })=>slug === node.relationTo).fields.find((field)=>fieldAffectsData(field) && field.name === 'id');
+            const type = getIDType(idField, db?.defaultIDType);
+            if (!isValidID(node.value?.id, type)) {
+                return t('validation:validUploadID');
+            }
+        }
+        // TODO: validate upload collection fields
+        return true;
+    };
+    return uploadValidation;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy91cGxvYWQvdmFsaWRhdGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZmllbGRBZmZlY3RzRGF0YSB9IGZyb20gJ3BheWxvYWQvdHlwZXMnXG5pbXBvcnQgeyBnZXRJRFR5cGUsIGlzVmFsaWRJRCB9IGZyb20gJ3BheWxvYWQvdXRpbGl0aWVzJ1xuXG5pbXBvcnQgdHlwZSB7IE5vZGVWYWxpZGF0aW9uIH0gZnJvbSAnLi4vdHlwZXMnXG5pbXBvcnQgdHlwZSB7IFNlcmlhbGl6ZWRVcGxvYWROb2RlIH0gZnJvbSAnLi9ub2Rlcy9VcGxvYWROb2RlJ1xuXG5pbXBvcnQgeyBDQU5fVVNFX0RPTSB9IGZyb20gJy4uLy4uL2xleGljYWwvdXRpbHMvY2FuVXNlRE9NJ1xuXG5leHBvcnQgY29uc3QgdXBsb2FkVmFsaWRhdGlvbiA9ICgpOiBOb2RlVmFsaWRhdGlvbjxTZXJpYWxpemVkVXBsb2FkTm9kZT4gPT4ge1xuICBjb25zdCB1cGxvYWRWYWxpZGF0aW9uOiBOb2RlVmFsaWRhdGlvbjxTZXJpYWxpemVkVXBsb2FkTm9kZT4gPSAoe1xuICAgIG5vZGUsXG4gICAgdmFsaWRhdGlvbjoge1xuICAgICAgb3B0aW9uczoge1xuICAgICAgICByZXE6IHtcbiAgICAgICAgICBwYXlsb2FkOiB7IGNvbmZpZywgZGIgfSxcbiAgICAgICAgICB0LFxuICAgICAgICB9LFxuICAgICAgfSxcbiAgICB9LFxuICB9KSA9PiB7XG4gICAgaWYgKCFDQU5fVVNFX0RPTSkge1xuICAgICAgY29uc3QgaWRGaWVsZCA9IGNvbmZpZy5jb2xsZWN0aW9uc1xuICAgICAgICAuZmluZCgoeyBzbHVnIH0pID0+IHNsdWcgPT09IG5vZGUucmVsYXRpb25UbylcbiAgICAgICAgLmZpZWxkcy5maW5kKChmaWVsZCkgPT4gZmllbGRBZmZlY3RzRGF0YShmaWVsZCkgJiYgZmllbGQubmFtZSA9PT0gJ2lkJylcblxuICAgICAgY29uc3QgdHlwZSA9IGdldElEVHlwZShpZEZpZWxkLCBkYj8uZGVmYXVsdElEVHlwZSlcblxuICAgICAgaWYgKCFpc1ZhbGlkSUQobm9kZS52YWx1ZT8uaWQsIHR5cGUpKSB7XG4gICAgICAgIHJldHVybiB0KCd2YWxpZGF0aW9uOnZhbGlkVXBsb2FkSUQnKVxuICAgICAgfVxuICAgIH1cblxuICAgIC8vIFRPRE86IHZhbGlkYXRlIHVwbG9hZCBjb2xsZWN0aW9uIGZpZWxkc1xuXG4gICAgcmV0dXJuIHRydWVcbiAgfVxuXG4gIHJldHVybiB1cGxvYWRWYWxpZGF0aW9uXG59XG4iXSwibmFtZXMiOlsiZmllbGRBZmZlY3RzRGF0YSIsImdldElEVHlwZSIsImlzVmFsaWRJRCIsIkNBTl9VU0VfRE9NIiwidXBsb2FkVmFsaWRhdGlvbiIsIm5vZGUiLCJ2YWxpZGF0aW9uIiwib3B0aW9ucyIsInJlcSIsInBheWxvYWQiLCJjb25maWciLCJkYiIsInQiLCJpZEZpZWxkIiwiY29sbGVjdGlvbnMiLCJmaW5kIiwic2x1ZyIsInJlbGF0aW9uVG8iLCJmaWVsZHMiLCJmaWVsZCIsIm5hbWUiLCJ0eXBlIiwiZGVmYXVsdElEVHlwZSIsInZhbHVlIiwiaWQiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGdCQUFnQixRQUFRLGdCQUFlO0FBQ2hELFNBQVNDLFNBQVMsRUFBRUMsU0FBUyxRQUFRLG9CQUFtQjtBQUt4RCxTQUFTQyxXQUFXLFFBQVEsZ0NBQStCO0FBRTNELE9BQU8sTUFBTUMsbUJBQW1CO0lBQzlCLE1BQU1BLG1CQUF5RCxDQUFDLEVBQzlEQyxJQUFJLEVBQ0pDLFlBQVksRUFDVkMsU0FBUyxFQUNQQyxLQUFLLEVBQ0hDLFNBQVMsRUFBRUMsTUFBTSxFQUFFQyxFQUFFLEVBQUUsRUFDdkJDLENBQUMsRUFDRixFQUNGLEVBQ0YsRUFDRjtRQUNDLElBQUksQ0FBQ1QsYUFBYTtZQUNoQixNQUFNVSxVQUFVSCxPQUFPSSxXQUFXLENBQy9CQyxJQUFJLENBQUMsQ0FBQyxFQUFFQyxJQUFJLEVBQUUsR0FBS0EsU0FBU1gsS0FBS1ksVUFBVSxFQUMzQ0MsTUFBTSxDQUFDSCxJQUFJLENBQUMsQ0FBQ0ksUUFBVW5CLGlCQUFpQm1CLFVBQVVBLE1BQU1DLElBQUksS0FBSztZQUVwRSxNQUFNQyxPQUFPcEIsVUFBVVksU0FBU0YsSUFBSVc7WUFFcEMsSUFBSSxDQUFDcEIsVUFBVUcsS0FBS2tCLEtBQUssRUFBRUMsSUFBSUgsT0FBTztnQkFDcEMsT0FBT1QsRUFBRTtZQUNYO1FBQ0Y7UUFFQSwwQ0FBMEM7UUFFMUMsT0FBTztJQUNUO0lBRUEsT0FBT1I7QUFDVCxFQUFDIn0=

package/dist/field/index.d.ts

@@ -1,4 +1,9 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
+import { type FormFieldBase } from '@payloadcms/ui';
 import React from 'react';
-import type { FieldProps } from '../types';
-export declare const RichTextField: React.FC<FieldProps>;
+export declare const RichTextField: React.FC<FormFieldBase & {
+    lexicalEditorConfig: LexicalEditorConfig;
+    name: string;
+    richTextComponentMap: Map<string, React.ReactNode>;
+}>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/field/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAyB,MAAM,OAAO,CAAA;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CAM9C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/field/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,gBAAgB,CAAA;AAGlE,OAAO,KAA8C,MAAM,OAAO,CAAA;AAalE,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAClC,aAAa,GAAG;IACd,mBAAmB,EAAE,mBAAmB,CAAA;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;CACnD,CA4GF,CAAA"}