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

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UploadFeature", {
+    enumerable: true,
+    get: function() {
+        return UploadFeature;
+    }
+});
+const _featureclient = require("./feature.client");
+const _UploadNode = require("./nodes/UploadNode");
+const _populationPromise = require("./populationPromise");
+const _validate = require("./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;
+}
+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: _featureclient.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.UploadNode.getType()
+                                ]
+                            }
+                        },
+                        node: _UploadNode.UploadNode,
+                        populationPromises: [
+                            (0, _populationPromise.uploadPopulationPromiseHOC)(props)
+                        ],
+                        validations: [
+                            (0, _validate.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":["UploadFeature","getAbsoluteURL","url","payload","startsWith","config","serverURL","props","collections","clientProps","collection","hasExtraFields","fields","length","feature","ClientComponent","UploadFeatureClientComponent","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","UploadNode","getType","populationPromises","uploadPopulationPromiseHOC","validations","uploadValidation","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,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    $createUploadNode: function() {
+        return $createUploadNode;
+    },
+    $isUploadNode: function() {
+        return $isUploadNode;
+    },
+    UploadNode: function() {
+        return UploadNode;
+    }
+});
+const _LexicalDecoratorBlockNode = require("@lexical/react/LexicalDecoratorBlockNode");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+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;
+}
+// @ts-expect-error-next-line TypeScript being dumb
+const RawUploadComponent = /*#__PURE__*/ _react.lazy(async ()=>await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../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;
+}
+class UploadNode extends _LexicalDecoratorBlockNode.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;
+    }
+}
+function $createUploadNode({ data }) {
+    return (0, _lexical.$applyNodeReplacement)(new UploadNode({
+        data
+    }));
+}
+function $isUploadNode(node) {
+    return node instanceof UploadNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/upload/nodes/UploadNode.tsx"],"sourcesContent":["import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode'\nimport type { ElementFormatType, NodeKey } from 'lexical'\n\nimport { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode'\nimport {\n  $applyNodeReplacement,\n  type DOMConversionMap,\n  type DOMConversionOutput,\n  type DOMExportOutput,\n  type LexicalNode,\n  type Spread,\n} from 'lexical'\nimport * as React from 'react'\n\n// @ts-expect-error-next-line TypeScript being dumb\nconst RawUploadComponent = React.lazy(async () => await import('../component'))\n\nexport type RawUploadPayload = {\n  fields: {\n    // unknown, custom fields:\n    [key: string]: unknown\n  }\n  id: string\n  relationTo: string\n}\n\nexport type UploadData = {\n  fields: {\n    // unknown, custom fields:\n    [key: string]: unknown\n  }\n  relationTo: string\n  value: {\n    // Actual upload data, populated in afterRead hook\n    [key: string]: unknown\n    id: string\n  }\n}\n\nfunction convertUploadElement(domNode: Node): DOMConversionOutput | null {\n  if (domNode instanceof HTMLImageElement) {\n    // const { alt: altText, src } = domNode;\n    // const node = $createImageNode({ altText, src });\n    // return { node };\n    // TODO: Auto-upload functionality here!\n  }\n  return null\n}\n\nexport type SerializedUploadNode = Spread<UploadData, SerializedDecoratorBlockNode>\n\nexport class UploadNode extends DecoratorBlockNode {\n  __data: UploadData\n\n  constructor({\n    data,\n    format,\n    key,\n  }: {\n    data: UploadData\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__data = data\n  }\n\n  static clone(node: UploadNode): UploadNode {\n    return new UploadNode({\n      data: node.__data,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'upload'\n  }\n\n  static importDOM(): DOMConversionMap | null {\n    return {\n      img: (node: Node) => ({\n        conversion: convertUploadElement,\n        priority: 0,\n      }),\n    }\n  }\n\n  static importJSON(serializedNode: SerializedUploadNode): UploadNode {\n    const importedData: UploadData = {\n      fields: serializedNode.fields,\n      relationTo: serializedNode.relationTo,\n      value: serializedNode.value,\n    }\n\n    const node = $createUploadNode({ data: importedData })\n    node.setFormat(serializedNode.format)\n\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n\n  decorate(): JSX.Element {\n    return <RawUploadComponent data={this.__data} format={this.__format} nodeKey={this.getKey()} />\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('img')\n    // element.setAttribute('src', this.__src);\n    // element.setAttribute('alt', this.__altText); //TODO\n    return { element }\n  }\n\n  exportJSON(): SerializedUploadNode {\n    return {\n      ...super.exportJSON(),\n      ...this.getData(),\n      type: this.getType(),\n      version: 1,\n    }\n  }\n\n  getData(): UploadData {\n    return this.getLatest().__data\n  }\n\n  setData(data: UploadData): void {\n    const writable = this.getWritable()\n    writable.__data = data\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  updateDOM(): false {\n    return false\n  }\n}\n\nexport function $createUploadNode({ data }: { data: UploadData }): UploadNode {\n  return $applyNodeReplacement(new UploadNode({ data }))\n}\n\nexport function $isUploadNode(node: LexicalNode | null | undefined): node is UploadNode {\n  return node instanceof UploadNode\n}\n"],"names":["$createUploadNode","$isUploadNode","UploadNode","RawUploadComponent","React","lazy","convertUploadElement","domNode","HTMLImageElement","DecoratorBlockNode","__data","constructor","data","format","key","clone","node","__format","__key","getType","importDOM","img","conversion","priority","importJSON","serializedNode","importedData","fields","relationTo","value","setFormat","isInline","decorate","nodeKey","getKey","exportDOM","element","document","createElement","exportJSON","getData","type","version","getLatest","setData","writable","getWritable","updateDOM","$applyNodeReplacement"],"mappings":";;;;;;;;;;;IA4IgBA,iBAAiB;eAAjBA;;IAIAC,aAAa;eAAbA;;IA7FHC,UAAU;eAAVA;;;2CAhDsB;yBAQ5B;+DACgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvB,mDAAmD;AACnD,MAAMC,mCAAqBC,OAAMC,IAAI,CAAC,UAAY,MAAM,mEAAA,QAAO;AAwB/D,SAASC,qBAAqBC,OAAa;IACzC,IAAIA,mBAAmBC,kBAAkB;IACvC,yCAAyC;IACzC,mDAAmD;IACnD,mBAAmB;IACnB,wCAAwC;IAC1C;IACA,OAAO;AACT;AAIO,MAAMN,mBAAmBO,6CAAkB;IAChDC,OAAkB;IAElBC,YAAY,EACVC,IAAI,EACJC,MAAM,EACNC,GAAG,EAKJ,CAAE;QACD,KAAK,CAACD,QAAQC;QACd,IAAI,CAACJ,MAAM,GAAGE;IAChB;IAEA,OAAOG,MAAMC,IAAgB,EAAc;QACzC,OAAO,IAAId,WAAW;YACpBU,MAAMI,KAAKN,MAAM;YACjBG,QAAQG,KAAKC,QAAQ;YACrBH,KAAKE,KAAKE,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,YAAqC;QAC1C,OAAO;YACLC,KAAK,CAACL,OAAgB,CAAA;oBACpBM,YAAYhB;oBACZiB,UAAU;gBACZ,CAAA;QACF;IACF;IAEA,OAAOC,WAAWC,cAAoC,EAAc;QAClE,MAAMC,eAA2B;YAC/BC,QAAQF,eAAeE,MAAM;YAC7BC,YAAYH,eAAeG,UAAU;YACrCC,OAAOJ,eAAeI,KAAK;QAC7B;QAEA,MAAMb,OAAOhB,kBAAkB;YAAEY,MAAMc;QAAa;QACpDV,KAAKc,SAAS,CAACL,eAAeZ,MAAM;QAEpC,OAAOG;IACT;IAEA,OAAOe,WAAkB;QACvB,OAAO;IACT;IAEAC,WAAwB;QACtB,qBAAO,qBAAC7B;YAAmBS,MAAM,IAAI,CAACF,MAAM;YAAEG,QAAQ,IAAI,CAACI,QAAQ;YAAEgB,SAAS,IAAI,CAACC,MAAM;;IAC3F;IAEAC,YAA6B;QAC3B,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC,2CAA2C;QAC3C,sDAAsD;QACtD,OAAO;YAAEF;QAAQ;IACnB;IAEAG,aAAmC;QACjC,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrB,GAAG,IAAI,CAACC,OAAO,EAAE;YACjBC,MAAM,IAAI,CAACtB,OAAO;YAClBuB,SAAS;QACX;IACF;IAEAF,UAAsB;QACpB,OAAO,IAAI,CAACG,SAAS,GAAGjC,MAAM;IAChC;IAEAkC,QAAQhC,IAAgB,EAAQ;QAC9B,MAAMiC,WAAW,IAAI,CAACC,WAAW;QACjCD,SAASnC,MAAM,GAAGE;IACpB;IAEA,kDAAkD;IAClDmC,YAAmB;QACjB,OAAO;IACT;AACF;AAEO,SAAS/C,kBAAkB,EAAEY,IAAI,EAAwB;IAC9D,OAAOoC,IAAAA,8BAAqB,EAAC,IAAI9C,WAAW;QAAEU;IAAK;AACrD;AAEO,SAASX,cAAce,IAAoC;IAChE,OAAOA,gBAAgBd;AACzB"}

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,111 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INSERT_UPLOAD_COMMAND: function() {
+        return INSERT_UPLOAD_COMMAND;
+    },
+    UploadPlugin: function() {
+        return UploadPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _ui = require("@payloadcms/ui");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _drawer = require("../drawer");
+const _UploadNode = require("../nodes/UploadNode");
+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 INSERT_UPLOAD_COMMAND = (0, _lexical.createCommand)('INSERT_UPLOAD_COMMAND');
+function UploadPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { collections } = (0, _ui.useConfig)();
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _UploadNode.UploadNode
+        ])) {
+            throw new Error('UploadPlugin: UploadNode not registered on editor');
+        }
+        return (0, _utils.mergeRegister)(editor.registerCommand(INSERT_UPLOAD_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const uploadNode = (0, _UploadNode.$createUploadNode)({
+                    data: {
+                        fields: payload.fields,
+                        relationTo: payload.relationTo,
+                        value: {
+                            id: payload.id
+                        }
+                    }
+                });
+                const selection = (0, _lexical.$getSelection)() || (0, _lexical.$getPreviousSelection)();
+                if ((0, _lexical.$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 ((0, _lexical.$isParagraphNode)(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParent().getChildren().filter((node)=>(0, _lexical.$isParagraphNode)(node)).length > 1) {
+                        focusNode.remove();
+                    }
+                    (0, _utils.$insertNodeToNearestRoot)(uploadNode);
+                }
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_drawer.UploadDrawer, {
+        enabledCollectionSlugs: collections.map(({ slug })=>slug)
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "uploadPopulationPromiseHOC", {
+    enumerable: true,
+    get: function() {
+        return uploadPopulationPromiseHOC;
+    }
+});
+const _populate = require("../../../populate/populate");
+const _recurseNestedFields = require("../../../populate/recurseNestedFields");
+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((0, _populate.populate)({
+                    id: node?.value?.id,
+                    collection,
+                    currentDepth,
+                    data: node,
+                    depth,
+                    field,
+                    key: 'value',
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+            if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {
+                (0, _recurseNestedFields.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,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "uploadValidation", {
+    enumerable: true,
+    get: function() {
+        return uploadValidation;
+    }
+});
+const _types = require("payload/types");
+const _utilities = require("payload/utilities");
+const _canUseDOM = require("../../lexical/utils/canUseDOM");
+const uploadValidation = ()=>{
+    const uploadValidation = ({ node, validation: { options: { req: { payload: { config, db }, t } } } })=>{
+        if (!_canUseDOM.CAN_USE_DOM) {
+            const idField = config.collections.find(({ slug })=>slug === node.relationTo).fields.find((field)=>(0, _types.fieldAffectsData)(field) && field.name === 'id');
+            const type = (0, _utilities.getIDType)(idField, db?.defaultIDType);
+            if (!(0, _utilities.isValidID)(node.value?.id, type)) {
+                return t('validation:validUploadID');
+            }
+        }
+        // TODO: validate upload collection fields
+        return true;
+    };
+    return uploadValidation;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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