@payloadcms/richtext-lexical 3.0.0-canary.92e4997 → 3.0.0-canary.95fcd13

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

@@ -1,80 +0,0 @@
-'use client';
-import { $isNodeSelection } from 'lexical';
-import { UploadIcon } from '../../lexical/ui/icons/Upload/index.js';
-import { createClientComponent } from '../createClientComponent.js';
-import { toolbarAddDropdownGroupWithItems } from '../shared/toolbar/addDropdownGroup.js';
-import { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from './drawer/commands.js';
-import { $isUploadNode, UploadNode } from './nodes/UploadNode.js';
-import { UploadPlugin } from './plugin/index.js';
-const UploadFeatureClient = (props)=>{
-    return {
-        clientFeatureProps: props,
-        feature: ()=>({
-                clientFeatureProps: props,
-                nodes: [
-                    UploadNode
-                ],
-                plugins: [
-                    {
-                        Component: UploadPlugin,
-                        position: 'normal'
-                    }
-                ],
-                slashMenu: {
-                    groups: [
-                        {
-                            items: [
-                                {
-                                    Icon: UploadIcon,
-                                    key: 'upload',
-                                    keywords: [
-                                        'upload',
-                                        'image',
-                                        'file',
-                                        'img',
-                                        'picture',
-                                        'photo',
-                                        'media'
-                                    ],
-                                    label: 'Upload',
-                                    onSelect: ({ editor })=>{
-                                        editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
-                                            replace: false
-                                        });
-                                    }
-                                }
-                            ],
-                            key: 'basic',
-                            label: 'Basic'
-                        }
-                    ]
-                },
-                toolbarFixed: {
-                    groups: [
-                        toolbarAddDropdownGroupWithItems([
-                            {
-                                ChildComponent: UploadIcon,
-                                isActive: ({ selection })=>{
-                                    if (!$isNodeSelection(selection) || !selection.getNodes().length) {
-                                        return false;
-                                    }
-                                    const firstNode = selection.getNodes()[0];
-                                    return $isUploadNode(firstNode);
-                                },
-                                key: 'upload',
-                                label: 'Upload',
-                                onSelect: ({ editor })=>{
-                                    editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
-                                        replace: false
-                                    });
-                                }
-                            }
-                        ])
-                    ]
-                }
-            })
-    };
-};
-export const UploadFeatureClientComponent = createClientComponent(UploadFeatureClient);
-
-//# sourceMappingURL=feature.client.js.map

package/dist/field/features/upload/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/upload/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { $isNodeSelection } from 'lexical'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { UploadIcon } from '../../lexical/ui/icons/Upload/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { toolbarAddDropdownGroupWithItems } from '../shared/toolbar/addDropdownGroup.js'\nimport { INSERT_UPLOAD_WITH_DRAWER_COMMAND } from './drawer/commands.js'\nimport { $isUploadNode, UploadNode } from './nodes/UploadNode.js'\nimport { UploadPlugin } from './plugin/index.js'\n\nexport type UploadFeaturePropsClient = {\n  collections: {\n    [collection: string]: {\n      hasExtraFields: boolean\n    }\n  }\n}\n\nconst UploadFeatureClient: FeatureProviderProviderClient<UploadFeaturePropsClient> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      nodes: [UploadNode],\n      plugins: [\n        {\n          Component: UploadPlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        groups: [\n          {\n            items: [\n              {\n                Icon: UploadIcon,\n                key: 'upload',\n                keywords: ['upload', 'image', 'file', 'img', 'picture', 'photo', 'media'],\n                label: 'Upload',\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {\n                    replace: false,\n                  })\n                },\n              },\n            ],\n            key: 'basic',\n            label: 'Basic',\n          },\n        ],\n      },\n      toolbarFixed: {\n        groups: [\n          toolbarAddDropdownGroupWithItems([\n            {\n              ChildComponent: UploadIcon,\n              isActive: ({ selection }) => {\n                if (!$isNodeSelection(selection) || !selection.getNodes().length) {\n                  return false\n                }\n\n                const firstNode = selection.getNodes()[0]\n                return $isUploadNode(firstNode)\n              },\n              key: 'upload',\n              label: 'Upload',\n              onSelect: ({ editor }) => {\n                editor.dispatchCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, {\n                  replace: false,\n                })\n              },\n            },\n          ]),\n        ],\n      },\n    }),\n  }\n}\n\nexport const UploadFeatureClientComponent = createClientComponent(UploadFeatureClient)\n"],"names":["$isNodeSelection","UploadIcon","createClientComponent","toolbarAddDropdownGroupWithItems","INSERT_UPLOAD_WITH_DRAWER_COMMAND","$isUploadNode","UploadNode","UploadPlugin","UploadFeatureClient","props","clientFeatureProps","feature","nodes","plugins","Component","position","slashMenu","groups","items","Icon","key","keywords","label","onSelect","editor","dispatchCommand","replace","toolbarFixed","ChildComponent","isActive","selection","getNodes","length","firstNode","UploadFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,gBAAgB,QAAQ,UAAS;AAI1C,SAASC,UAAU,QAAQ,yCAAwC;AACnE,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,gCAAgC,QAAQ,wCAAuC;AACxF,SAASC,iCAAiC,QAAQ,uBAAsB;AACxE,SAASC,aAAa,EAAEC,UAAU,QAAQ,wBAAuB;AACjE,SAASC,YAAY,QAAQ,oBAAmB;AAUhD,MAAMC,sBAA+E,CAACC;IACpF,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,OAAO;oBAACN;iBAAW;gBACnBO,SAAS;oBACP;wBACEC,WAAWP;wBACXQ,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,QAAQ;wBACN;4BACEC,OAAO;gCACL;oCACEC,MAAMlB;oCACNmB,KAAK;oCACLC,UAAU;wCAAC;wCAAU;wCAAS;wCAAQ;wCAAO;wCAAW;wCAAS;qCAAQ;oCACzEC,OAAO;oCACPC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACrB,mCAAmC;4CACxDsB,SAAS;wCACX;oCACF;gCACF;6BACD;4BACDN,KAAK;4BACLE,OAAO;wBACT;qBACD;gBACH;gBACAK,cAAc;oBACZV,QAAQ;wBACNd,iCAAiC;4BAC/B;gCACEyB,gBAAgB3B;gCAChB4B,UAAU,CAAC,EAAEC,SAAS,EAAE;oCACtB,IAAI,CAAC9B,iBAAiB8B,cAAc,CAACA,UAAUC,QAAQ,GAAGC,MAAM,EAAE;wCAChE,OAAO;oCACT;oCAEA,MAAMC,YAAYH,UAAUC,QAAQ,EAAE,CAAC,EAAE;oCACzC,OAAO1B,cAAc4B;gCACvB;gCACAb,KAAK;gCACLE,OAAO;gCACPC,UAAU,CAAC,EAAEC,MAAM,EAAE;oCACnBA,OAAOC,eAAe,CAACrB,mCAAmC;wCACxDsB,SAAS;oCACX;gCACF;4BACF;yBACD;qBACF;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMQ,+BAA+BhC,sBAAsBM,qBAAoB"}

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

@@ -1,19 +0,0 @@
-import type { Field } from 'payload/types';
-import type { FeatureProviderProviderServer } from '../types.js';
-import type { UploadFeaturePropsClient } from './feature.client.js';
-export type UploadFeatureProps = {
-    collections?: {
-        [collection: string]: {
-            fields: Field[];
-        };
-    };
-    /**
-     * Sets a maximum population depth for this upload (not the fields for this upload), regardless of the remaining depth when the respective field is reached.
-     * This behaves exactly like the maxDepth properties of relationship and upload fields.
-     *
-     * {@link https://payloadcms.com/docs/getting-started/concepts#field-level-max-depth}
-     */
-    maxDepth?: number;
-};
-export declare const UploadFeature: FeatureProviderProviderServer<UploadFeatureProps, UploadFeaturePropsClient>;
-//# sourceMappingURL=feature.server.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/feature.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAA2C,MAAM,eAAe,CAAA;AAKnF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAQnE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE;QACZ,CAAC,UAAU,EAAE,MAAM,GAAG;YACpB,MAAM,EAAE,KAAK,EAAE,CAAA;SAChB,CAAA;KACF,CAAA;IACD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AASD,eAAO,MAAM,aAAa,EAAE,6BAA6B,CACvD,kBAAkB,EAClB,wBAAwB,CAqJzB,CAAA"}

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

@@ -1,138 +0,0 @@
-import { traverseFields } from '@payloadcms/next/utilities';
-import { sanitizeFields } from 'payload/config';
-import { createNode } from '../typeUtilities.js';
-import { UploadFeatureClientComponent } from './feature.client.js';
-import { UploadNode } from './nodes/UploadNode.js';
-import { uploadPopulationPromiseHOC } from './populationPromise.js';
-import { uploadValidation } from './validate.js';
-/**
- * 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: async ({ config: _config, isRoot })=>{
-            const validRelationships = _config.collections.map((c)=>c.slug) || [];
-            for(const collection in props.collections){
-                if (props.collections[collection].fields?.length) {
-                    props.collections[collection].fields = await sanitizeFields({
-                        config: _config,
-                        fields: props.collections[collection].fields,
-                        requireFieldLevelRichTextEditor: isRoot,
-                        validRelationships
-                    });
-                }
-            }
-            return {
-                ClientComponent: UploadFeatureClientComponent,
-                clientFeatureProps: clientProps,
-                generateSchemaMap: ({ config, i18n, props })=>{
-                    if (!props?.collections) return null;
-                    const schemaMap = new Map();
-                    const validRelationships = config.collections.map((c)=>c.slug) || [];
-                    for(const collection in props.collections){
-                        if (props.collections[collection].fields?.length) {
-                            schemaMap.set(collection, props.collections[collection].fields);
-                            traverseFields({
-                                config,
-                                fields: props.collections[collection].fields,
-                                i18n,
-                                schemaMap,
-                                schemaPath: collection,
-                                validRelationships
-                            });
-                        }
-                    }
-                    return schemaMap;
-                },
-                nodes: [
-                    createNode({
-                        converters: {
-                            html: {
-                                converter: async ({ node, payload })=>{
-                                    // @ts-expect-error
-                                    const id = node?.value?.id || node?.value // for backwards-compatibility
-                                    ;
-                                    if (payload) {
-                                        let uploadDocument;
-                                        try {
-                                            uploadDocument = await payload.findByID({
-                                                id,
-                                                collection: node.relationTo
-                                            });
-                                        } catch (ignored) {
-                                            // eslint-disable-next-line no-console
-                                            console.error('Lexical upload node HTML converter: error fetching upload file', ignored, 'Node:', node);
-                                            return `<img />`;
-                                        }
-                                        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="${id}" />`;
-                                    }
-                                },
-                                nodeTypes: [
-                                    UploadNode.getType()
-                                ]
-                            }
-                        },
-                        node: UploadNode,
-                        populationPromises: [
-                            uploadPopulationPromiseHOC(props)
-                        ],
-                        validations: [
-                            uploadValidation(props)
-                        ]
-                    })
-                ],
-                serverFeatureProps: props
-            };
-        },
-        key: 'upload',
-        serverFeatureProps: props
-    };
-};
-
-//# sourceMappingURL=feature.server.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/upload/feature.server.ts"],"sourcesContent":["import type { Config } from 'payload/config'\nimport type { Field, FileData, FileSize, Payload, TypeWithID } from 'payload/types'\n\nimport { traverseFields } from '@payloadcms/next/utilities'\nimport { sanitizeFields } from 'payload/config'\n\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { UploadFeaturePropsClient } from './feature.client.js'\n\nimport { createNode } from '../typeUtilities.js'\nimport { UploadFeatureClientComponent } from './feature.client.js'\nimport { UploadNode } from './nodes/UploadNode.js'\nimport { uploadPopulationPromiseHOC } from './populationPromise.js'\nimport { uploadValidation } from './validate.js'\n\nexport type UploadFeatureProps = {\n  collections?: {\n    [collection: string]: {\n      fields: Field[]\n    }\n  }\n  /**\n   * Sets a maximum population depth for this upload (not the fields for this upload), regardless of the remaining depth when the respective field is reached.\n   * This behaves exactly like the maxDepth properties of relationship and upload fields.\n   *\n   * {@link https://payloadcms.com/docs/getting-started/concepts#field-level-max-depth}\n   */\n  maxDepth?: number\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 = {\n    collections: {},\n  }\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: async ({ config: _config, isRoot }) => {\n      const validRelationships = _config.collections.map((c) => c.slug) || []\n\n      for (const collection in props.collections) {\n        if (props.collections[collection].fields?.length) {\n          props.collections[collection].fields = await sanitizeFields({\n            config: _config as unknown as Config,\n            fields: props.collections[collection].fields,\n            requireFieldLevelRichTextEditor: isRoot,\n            validRelationships,\n          })\n        }\n      }\n\n      return {\n        ClientComponent: UploadFeatureClientComponent,\n        clientFeatureProps: clientProps,\n        generateSchemaMap: ({ config, i18n, props }) => {\n          if (!props?.collections) return null\n\n          const schemaMap = new Map<string, Field[]>()\n          const validRelationships = config.collections.map((c) => c.slug) || []\n\n          for (const collection in props.collections) {\n            if (props.collections[collection].fields?.length) {\n              schemaMap.set(collection, props.collections[collection].fields)\n              traverseFields({\n                config,\n                fields: props.collections[collection].fields,\n                i18n,\n                schemaMap,\n                schemaPath: collection,\n                validRelationships,\n              })\n            }\n          }\n\n          return schemaMap\n        },\n        nodes: [\n          createNode({\n            converters: {\n              html: {\n                converter: async ({ node, payload }) => {\n                  // @ts-expect-error\n                  const id = node?.value?.id || node?.value // for backwards-compatibility\n\n                  if (payload) {\n                    let uploadDocument: TypeWithID & FileData\n\n                    try {\n                      uploadDocument = (await payload.findByID({\n                        id,\n                        collection: node.relationTo,\n                      })) as TypeWithID & FileData\n                    } catch (ignored) {\n                      // eslint-disable-next-line no-console\n                      console.error(\n                        'Lexical upload node HTML converter: error fetching upload file',\n                        ignored,\n                        'Node:',\n                        node,\n                      )\n                      return `<img />`\n                    }\n\n                    const url = getAbsoluteURL(uploadDocument?.url, payload)\n\n                    /**\n                     * If the upload is not an image, return a link to the upload\n                     */\n                    if (!uploadDocument?.mimeType?.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: FileSize & {\n                        url?: string\n                      } = 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 = getAbsoluteURL(imageSize?.url, 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=\"${id}\" />`\n                  }\n                },\n                nodeTypes: [UploadNode.getType()],\n              },\n            },\n            node: UploadNode,\n            populationPromises: [uploadPopulationPromiseHOC(props)],\n            validations: [uploadValidation(props)],\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'upload',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["traverseFields","sanitizeFields","createNode","UploadFeatureClientComponent","UploadNode","uploadPopulationPromiseHOC","uploadValidation","getAbsoluteURL","url","payload","startsWith","config","serverURL","UploadFeature","props","collections","clientProps","collection","hasExtraFields","fields","length","feature","_config","isRoot","validRelationships","map","c","slug","requireFieldLevelRichTextEditor","ClientComponent","clientFeatureProps","generateSchemaMap","i18n","schemaMap","Map","set","schemaPath","nodes","converters","html","converter","node","id","value","uploadDocument","findByID","relationTo","ignored","console","error","mimeType","filename","sizes","Object","keys","width","height","pictureHTML","size","imageSize","filesize","imageSizeURL","nodeTypes","getType","populationPromises","validations","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,cAAc,QAAQ,6BAA4B;AAC3D,SAASC,cAAc,QAAQ,iBAAgB;AAK/C,SAASC,UAAU,QAAQ,sBAAqB;AAChD,SAASC,4BAA4B,QAAQ,sBAAqB;AAClE,SAASC,UAAU,QAAQ,wBAAuB;AAClD,SAASC,0BAA0B,QAAQ,yBAAwB;AACnE,SAASC,gBAAgB,QAAQ,gBAAe;AAiBhD;;CAEC,GACD,SAASC,eAAeC,GAAW,EAAEC,OAAgB;IACnD,OAAOD,KAAKE,WAAW,UAAUF,MAAM,AAACC,CAAAA,SAASE,QAAQC,aAAa,EAAC,IAAKJ;AAC9E;AAEA,OAAO,MAAMK,gBAGT,CAACC;IACH,IAAI,CAACA,OAAO;QACVA,QAAQ;YAAEC,aAAa,CAAC;QAAE;IAC5B;IAEA,MAAMC,cAAwC;QAC5CD,aAAa,CAAC;IAChB;IACA,IAAID,MAAMC,WAAW,EAAE;QACrB,IAAK,MAAME,cAAcH,MAAMC,WAAW,CAAE;YAC1CC,YAAYD,WAAW,CAACE,WAAW,GAAG;gBACpCC,gBAAgBJ,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM,CAACC,MAAM,IAAI;YACjE;QACF;IACF;IAEA,OAAO;QACLC,SAAS,OAAO,EAAEV,QAAQW,OAAO,EAAEC,MAAM,EAAE;YACzC,MAAMC,qBAAqBF,QAAQP,WAAW,CAACU,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;YAEvE,IAAK,MAAMV,cAAcH,MAAMC,WAAW,CAAE;gBAC1C,IAAID,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM,EAAEC,QAAQ;oBAChDN,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM,GAAG,MAAMlB,eAAe;wBAC1DU,QAAQW;wBACRH,QAAQL,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM;wBAC5CS,iCAAiCL;wBACjCC;oBACF;gBACF;YACF;YAEA,OAAO;gBACLK,iBAAiB1B;gBACjB2B,oBAAoBd;gBACpBe,mBAAmB,CAAC,EAAEpB,MAAM,EAAEqB,IAAI,EAAElB,KAAK,EAAE;oBACzC,IAAI,CAACA,OAAOC,aAAa,OAAO;oBAEhC,MAAMkB,YAAY,IAAIC;oBACtB,MAAMV,qBAAqBb,OAAOI,WAAW,CAACU,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;oBAEtE,IAAK,MAAMV,cAAcH,MAAMC,WAAW,CAAE;wBAC1C,IAAID,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM,EAAEC,QAAQ;4BAChDa,UAAUE,GAAG,CAAClB,YAAYH,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM;4BAC9DnB,eAAe;gCACbW;gCACAQ,QAAQL,MAAMC,WAAW,CAACE,WAAW,CAACE,MAAM;gCAC5Ca;gCACAC;gCACAG,YAAYnB;gCACZO;4BACF;wBACF;oBACF;oBAEA,OAAOS;gBACT;gBACAI,OAAO;oBACLnC,WAAW;wBACToC,YAAY;4BACVC,MAAM;gCACJC,WAAW,OAAO,EAAEC,IAAI,EAAEhC,OAAO,EAAE;oCACjC,mBAAmB;oCACnB,MAAMiC,KAAKD,MAAME,OAAOD,MAAMD,MAAME,MAAM,8BAA8B;;oCAExE,IAAIlC,SAAS;wCACX,IAAImC;wCAEJ,IAAI;4CACFA,iBAAkB,MAAMnC,QAAQoC,QAAQ,CAAC;gDACvCH;gDACAzB,YAAYwB,KAAKK,UAAU;4CAC7B;wCACF,EAAE,OAAOC,SAAS;4CAChB,sCAAsC;4CACtCC,QAAQC,KAAK,CACX,kEACAF,SACA,SACAN;4CAEF,OAAO,CAAC,OAAO,CAAC;wCAClB;wCAEA,MAAMjC,MAAMD,eAAeqC,gBAAgBpC,KAAKC;wCAEhD;;qBAEC,GACD,IAAI,CAACmC,gBAAgBM,UAAUxC,WAAW,UAAU;4CAClD,OAAO,CAAC,SAAS,EAAEF,IAAI,4BAA4B,EAAEoC,eAAeO,QAAQ,CAAC,IAAI,CAAC;wCACpF;wCAEA;;qBAEC,GACD,IAAI,CAACP,gBAAgBQ,SAAS,CAACC,OAAOC,IAAI,CAACV,gBAAgBQ,OAAOhC,MAAM,EAAE;4CACxE,OAAO,CAAC,UAAU,EAAEZ,IAAI,OAAO,EAAEoC,gBAAgBO,SAAS,SAAS,EAAEP,gBAAgBW,MAAM,WAAW,EAAEX,gBAAgBY,OAAO,GAAG,CAAC;wCACrI;wCAEA;;qBAEC,GACD,IAAIC,cAAc;wCAElB,qDAAqD;wCACrD,IAAK,MAAMC,QAAQd,eAAeQ,KAAK,CAAE;4CACvC,MAAMO,YAEFf,eAAeQ,KAAK,CAACM,KAAK;4CAE9B,kDAAkD;4CAClD,IACE,CAACC,UAAUJ,KAAK,IAChB,CAACI,UAAUH,MAAM,IACjB,CAACG,UAAUT,QAAQ,IACnB,CAACS,UAAUC,QAAQ,IACnB,CAACD,UAAUR,QAAQ,IACnB,CAACQ,UAAUnD,GAAG,EACd;gDACA;4CACF;4CACA,MAAMqD,eAAetD,eAAeoD,WAAWnD,KAAKC;4CAEpDgD,eAAe,CAAC,gBAAgB,EAAEI,aAAa,qBAAqB,EAAEF,UAAUJ,KAAK,CAAC,WAAW,EAAEI,UAAUT,QAAQ,CAAC,EAAE,CAAC;wCAC3H;wCAEA,0BAA0B;wCAC1BO,eAAe,CAAC,UAAU,EAAEjD,IAAI,qBAAqB,EAAEoC,eAAeW,KAAK,CAAC,UAAU,EAAEX,eAAeY,MAAM,CAAC,EAAE,CAAC;wCACjHC,eAAe;wCACf,OAAOA;oCACT,OAAO;wCACL,OAAO,CAAC,UAAU,EAAEf,GAAG,IAAI,CAAC;oCAC9B;gCACF;gCACAoB,WAAW;oCAAC1D,WAAW2D,OAAO;iCAAG;4BACnC;wBACF;wBACAtB,MAAMrC;wBACN4D,oBAAoB;4BAAC3D,2BAA2BS;yBAAO;wBACvDmD,aAAa;4BAAC3D,iBAAiBQ;yBAAO;oBACxC;iBACD;gBACDoD,oBAAoBpD;YACtB;QACF;QACAqD,KAAK;QACLD,oBAAoBpD;IACtB;AACF,EAAC"}

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

@@ -1,37 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
-import type { ElementFormatType, NodeKey } from 'lexical';
-import type { DOMConversionMap, DOMExportOutput, LexicalNode, Spread } from 'lexical';
-import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
-export type UploadData = {
-    fields: {
-        [key: string]: unknown;
-    };
-    relationTo: string;
-    value: number | 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

@@ -1 +0,0 @@
-{"version":3,"file":"UploadNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/nodes/UploadNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6CAA6C,CAAA;AAC/F,OAAO,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,WAAW,EACX,MAAM,EACP,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAA;AAQhF,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,MAAM,GAAG,MAAM,CAAA;CACvB,CAAA;AA0BD,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;IAiBnE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAIxB,QAAQ,IAAI,GAAG,CAAC,OAAO;IAKvB,SAAS,IAAI,eAAe;IAQ5B,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

@@ -1,115 +0,0 @@
-import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
-import { $applyNodeReplacement } from 'lexical';
-import * as React from 'react';
-const RawUploadComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
-            default: module.UploadComponent
-        })));
-function convertUploadElement(domNode) {
-    if (domNode.hasAttribute('data-lexical-upload-relation-to') && domNode.hasAttribute('data-lexical-upload-id')) {
-        const id = domNode.getAttribute('data-lexical-upload-id');
-        const relationTo = domNode.getAttribute('data-lexical-upload-relation-to');
-        if (id != null && relationTo != null) {
-            const node = $createUploadNode({
-                data: {
-                    fields: {},
-                    relationTo,
-                    value: id
-                }
-            });
-            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) {
-        if (serializedNode.version === 1 && serializedNode?.value?.id) {
-            serializedNode.value = serializedNode.value.id;
-        }
-        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() {
-        // @ts-expect-error
-        return /*#__PURE__*/ React.createElement(RawUploadComponent, {
-            data: this.__data,
-            format: this.__format,
-            nodeKey: this.getKey()
-        });
-    }
-    exportDOM() {
-        const element = document.createElement('img');
-        element.setAttribute('data-lexical-upload-id', String(this.__data?.value));
-        element.setAttribute('data-lexical-upload-relation-to', this.__data?.relationTo);
-        return {
-            element
-        };
-    }
-    exportJSON() {
-        return {
-            ...super.exportJSON(),
-            ...this.getData(),
-            type: this.getType(),
-            version: 2
-        };
-    }
-    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=UploadNode.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/upload/nodes/UploadNode.tsx"],"sourcesContent":["import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport type { ElementFormatType, NodeKey } from 'lexical'\nimport type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  LexicalNode,\n  Spread,\n} from 'lexical'\n\nimport { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport { $applyNodeReplacement } from 'lexical'\nimport * as React from 'react'\n\nconst RawUploadComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({ default: module.UploadComponent })),\n)\n\nexport type UploadData = {\n  fields: {\n    // unknown, custom fields:\n    [key: string]: unknown\n  }\n  relationTo: string\n  value: number | string\n}\n\nfunction convertUploadElement(domNode: HTMLImageElement): DOMConversionOutput | null {\n  if (\n    domNode.hasAttribute('data-lexical-upload-relation-to') &&\n    domNode.hasAttribute('data-lexical-upload-id')\n  ) {\n    const id = domNode.getAttribute('data-lexical-upload-id')\n    const relationTo = domNode.getAttribute('data-lexical-upload-relation-to')\n\n    if (id != null && relationTo != null) {\n      const node = $createUploadNode({\n        data: {\n          fields: {},\n          relationTo,\n          value: id,\n        },\n      })\n      return { node }\n    }\n  }\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: HTMLImageElement) => ({\n        conversion: convertUploadElement,\n        priority: 0,\n      }),\n    }\n  }\n\n  static importJSON(serializedNode: SerializedUploadNode): UploadNode {\n    if (serializedNode.version === 1 && (serializedNode?.value as unknown as { id: string })?.id) {\n      serializedNode.value = (serializedNode.value as unknown as { id: string }).id\n    }\n\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    // @ts-expect-error\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('data-lexical-upload-id', String(this.__data?.value))\n    element.setAttribute('data-lexical-upload-relation-to', this.__data?.relationTo)\n\n    return { element }\n  }\n\n  exportJSON(): SerializedUploadNode {\n    return {\n      ...super.exportJSON(),\n      ...this.getData(),\n      type: this.getType(),\n      version: 2,\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":["DecoratorBlockNode","$applyNodeReplacement","React","RawUploadComponent","lazy","then","module","default","UploadComponent","convertUploadElement","domNode","hasAttribute","id","getAttribute","relationTo","node","$createUploadNode","data","fields","value","UploadNode","__data","constructor","format","key","clone","__format","__key","getType","importDOM","img","conversion","priority","importJSON","serializedNode","version","importedData","setFormat","isInline","decorate","nodeKey","getKey","exportDOM","element","document","createElement","setAttribute","String","exportJSON","getData","type","getLatest","setData","writable","getWritable","updateDOM","$isUploadNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,8 +0,0 @@
-import type { LexicalCommand } from 'lexical';
-import type { PluginComponentWithAnchor } from '../../types.js';
-import type { UploadFeaturePropsClient } from '../feature.client.js';
-import type { UploadData } from '../nodes/UploadNode.js';
-export type InsertUploadPayload = Readonly<UploadData>;
-export declare const INSERT_UPLOAD_COMMAND: LexicalCommand<InsertUploadPayload>;
-export declare const UploadPlugin: PluginComponentWithAnchor<UploadFeaturePropsClient>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/upload/plugin/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAe7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAKxD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAA;AAEtD,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,mBAAmB,CAC9B,CAAA;AAExC,eAAO,MAAM,YAAY,EAAE,yBAAyB,CAAC,wBAAwB,CAuD5E,CAAA"}

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

@@ -1,50 +0,0 @@
-'use client';
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
-import { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils';
-import { useConfig } from '@payloadcms/ui/providers/Config';
-import { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
-import React, { useEffect } from 'react';
-import { UploadDrawer } from '../drawer/index.js';
-import { $createUploadNode, UploadNode } from '../nodes/UploadNode.js';
-export const INSERT_UPLOAD_COMMAND = createCommand('INSERT_UPLOAD_COMMAND');
-export const UploadPlugin = ({ clientProps })=>{
-    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: payload.value
-                    }
-                });
-                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=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/upload/plugin/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalCommand } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils'\nimport { useConfig } from '@payloadcms/ui/providers/Config'\nimport {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n  createCommand,\n} from 'lexical'\nimport React, { useEffect } from 'react'\n\nimport type { PluginComponentWithAnchor } from '../../types.js'\nimport type { UploadFeaturePropsClient } from '../feature.client.js'\nimport type { UploadData } from '../nodes/UploadNode.js'\n\nimport { UploadDrawer } from '../drawer/index.js'\nimport { $createUploadNode, UploadNode } from '../nodes/UploadNode.js'\n\nexport type InsertUploadPayload = Readonly<UploadData>\n\nexport const INSERT_UPLOAD_COMMAND: LexicalCommand<InsertUploadPayload> =\n  createCommand('INSERT_UPLOAD_COMMAND')\n\nexport const UploadPlugin: PluginComponentWithAnchor<UploadFeaturePropsClient> = ({\n  clientProps,\n}) => {\n  const [editor] = useLexicalComposerContext()\n  const { collections } = useConfig()\n\n  useEffect(() => {\n    if (!editor.hasNodes([UploadNode])) {\n      throw new Error('UploadPlugin: UploadNode not registered on editor')\n    }\n\n    return mergeRegister(\n      editor.registerCommand<InsertUploadPayload>(\n        INSERT_UPLOAD_COMMAND,\n        (payload: InsertUploadPayload) => {\n          editor.update(() => {\n            const uploadNode = $createUploadNode({\n              data: {\n                fields: payload.fields,\n                relationTo: payload.relationTo,\n                value: payload.value,\n              },\n            })\n\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\n              const { focus } = selection\n              const focusNode = focus.getNode()\n\n              // First, delete currently selected node if it's an empty paragraph and if there are sufficient\n              // paragraph nodes (more than 1) left in the parent node, so that we don't \"trap\" the user\n              if (\n                $isParagraphNode(focusNode) &&\n                focusNode.getTextContentSize() === 0 &&\n                focusNode\n                  .getParent()\n                  .getChildren()\n                  .filter((node) => $isParagraphNode(node)).length > 1\n              ) {\n                focusNode.remove()\n              }\n\n              $insertNodeToNearestRoot(uploadNode)\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <UploadDrawer enabledCollectionSlugs={collections.map(({ slug }) => slug)} />\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","mergeRegister","useConfig","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","createCommand","React","useEffect","UploadDrawer","$createUploadNode","UploadNode","INSERT_UPLOAD_COMMAND","UploadPlugin","clientProps","editor","collections","hasNodes","Error","registerCommand","payload","update","uploadNode","data","fields","relationTo","value","selection","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove","enabledCollectionSlugs","map","slug"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAGA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,wBAAwB,EAAEC,aAAa,QAAQ,iBAAgB;AACxE,SAASC,SAAS,QAAQ,kCAAiC;AAC3D,SACEC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,EACvBC,aAAa,QACR,UAAS;AAChB,OAAOC,SAASC,SAAS,QAAQ,QAAO;AAMxC,SAASC,YAAY,QAAQ,qBAAoB;AACjD,SAASC,iBAAiB,EAAEC,UAAU,QAAQ,yBAAwB;AAItE,OAAO,MAAMC,wBACXN,cAAc,yBAAwB;AAExC,OAAO,MAAMO,eAAoE,CAAC,EAChFC,WAAW,EACZ;IACC,MAAM,CAACC,OAAO,GAAGlB;IACjB,MAAM,EAAEmB,WAAW,EAAE,GAAGhB;IAExBQ,UAAU;QACR,IAAI,CAACO,OAAOE,QAAQ,CAAC;YAACN;SAAW,GAAG;YAClC,MAAM,IAAIO,MAAM;QAClB;QAEA,OAAOnB,cACLgB,OAAOI,eAAe,CACpBP,uBACA,CAACQ;YACCL,OAAOM,MAAM,CAAC;gBACZ,MAAMC,aAAaZ,kBAAkB;oBACnCa,MAAM;wBACJC,QAAQJ,QAAQI,MAAM;wBACtBC,YAAYL,QAAQK,UAAU;wBAC9BC,OAAON,QAAQM,KAAK;oBACtB;gBACF;gBAEA,MAAMC,YAAYzB,mBAAmBD;gBAErC,IAAIG,kBAAkBuB,YAAY;oBAChC,MAAM,EAAEC,KAAK,EAAE,GAAGD;oBAClB,MAAME,YAAYD,MAAME,OAAO;oBAE/B,+FAA+F;oBAC/F,0FAA0F;oBAC1F,IACE3B,iBAAiB0B,cACjBA,UAAUE,kBAAkB,OAAO,KACnCF,UACGG,SAAS,GACTC,WAAW,GACXC,MAAM,CAAC,CAACC,OAAShC,iBAAiBgC,OAAOC,MAAM,GAAG,GACrD;wBACAP,UAAUQ,MAAM;oBAClB;oBAEAvC,yBAAyBwB;gBAC3B;YACF;YAEA,OAAO;QACT,GACAjB;IAGN,GAAG;QAACU;KAAO;IAEX,qBAAO,oBAACN;QAAa6B,wBAAwBtB,YAAYuB,GAAG,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA;;AAC7E,EAAC"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/populationPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAKjE,eAAO,MAAM,0BAA0B,WAC7B,kBAAkB,KACzB,kBAAkB,oBAAoB,CAmExC,CAAA"}

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

@@ -1,52 +0,0 @@
-import { populate } from '../../../populate/populate.js';
-import { recurseNestedFields } from '../../../populate/recurseNestedFields.js';
-export const uploadPopulationPromiseHOC = (props)=>{
-    return ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields })=>{
-        if (node?.value) {
-            const collection = req.payload.collections[node?.relationTo];
-            if (collection) {
-                // @ts-expect-error
-                const id = node?.value?.id || node?.value // for backwards-compatibility
-                ;
-                const populateDepth = props?.maxDepth !== undefined && props?.maxDepth < depth ? props?.maxDepth : depth;
-                populationPromises.push(populate({
-                    id,
-                    collection,
-                    currentDepth,
-                    data: node,
-                    depth: populateDepth,
-                    draft,
-                    field,
-                    key: 'value',
-                    overrideAccess,
-                    req,
-                    showHiddenFields
-                }));
-            }
-            if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {
-                if (!props?.collections?.[node?.relationTo]?.fields?.length) {
-                    return;
-                }
-                recurseNestedFields({
-                    context,
-                    currentDepth,
-                    data: node.fields || {},
-                    depth,
-                    draft,
-                    editorPopulationPromises,
-                    fieldPromises,
-                    fields: props?.collections?.[node?.relationTo]?.fields,
-                    findMany,
-                    flattenLocales,
-                    overrideAccess,
-                    populationPromises,
-                    req,
-                    showHiddenFields,
-                    siblingDoc: node.fields || {}
-                });
-            }
-        }
-    };
-};
-
-//# sourceMappingURL=populationPromise.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/upload/populationPromise.ts"],"sourcesContent":["import type { PopulationPromise } from '../types.js'\nimport type { UploadFeatureProps } from './feature.server.js'\nimport type { SerializedUploadNode } from './nodes/UploadNode.js'\n\nimport { populate } from '../../../populate/populate.js'\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const uploadPopulationPromiseHOC = (\n  props?: UploadFeatureProps,\n): PopulationPromise<SerializedUploadNode> => {\n  return ({\n    context,\n    currentDepth,\n    depth,\n    draft,\n    editorPopulationPromises,\n    field,\n    fieldPromises,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n  }) => {\n    if (node?.value) {\n      const collection = req.payload.collections[node?.relationTo]\n\n      if (collection) {\n        // @ts-expect-error\n        const id = node?.value?.id || node?.value // for backwards-compatibility\n\n        const populateDepth =\n          props?.maxDepth !== undefined && props?.maxDepth < depth ? props?.maxDepth : depth\n\n        populationPromises.push(\n          populate({\n            id,\n            collection,\n            currentDepth,\n            data: node,\n            depth: populateDepth,\n            draft,\n            field,\n            key: 'value',\n            overrideAccess,\n            req,\n            showHiddenFields,\n          }),\n        )\n      }\n      if (Array.isArray(props?.collections?.[node?.relationTo]?.fields)) {\n        if (!props?.collections?.[node?.relationTo]?.fields?.length) {\n          return\n        }\n        recurseNestedFields({\n          context,\n          currentDepth,\n          data: node.fields || {},\n          depth,\n          draft,\n          editorPopulationPromises,\n          fieldPromises,\n          fields: props?.collections?.[node?.relationTo]?.fields,\n          findMany,\n          flattenLocales,\n          overrideAccess,\n          populationPromises,\n          req,\n          showHiddenFields,\n          siblingDoc: node.fields || {},\n        })\n      }\n    }\n  }\n}\n"],"names":["populate","recurseNestedFields","uploadPopulationPromiseHOC","props","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","value","collection","payload","collections","relationTo","id","populateDepth","maxDepth","undefined","push","data","key","Array","isArray","fields","length","siblingDoc"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,QAAQ,QAAQ,gCAA+B;AACxD,SAASC,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,6BAA6B,CACxCC;IAEA,OAAO,CAAC,EACNC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,wBAAwB,EACxBC,KAAK,EACLC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EACjB;QACC,IAAIJ,MAAMK,OAAO;YACf,MAAMC,aAAaH,IAAII,OAAO,CAACC,WAAW,CAACR,MAAMS,WAAW;YAE5D,IAAIH,YAAY;gBACd,mBAAmB;gBACnB,MAAMI,KAAKV,MAAMK,OAAOK,MAAMV,MAAMK,MAAM,8BAA8B;;gBAExE,MAAMM,gBACJrB,OAAOsB,aAAaC,aAAavB,OAAOsB,WAAWnB,QAAQH,OAAOsB,WAAWnB;gBAE/ES,mBAAmBY,IAAI,CACrB3B,SAAS;oBACPuB;oBACAJ;oBACAd;oBACAuB,MAAMf;oBACNP,OAAOkB;oBACPjB;oBACAE;oBACAoB,KAAK;oBACLf;oBACAE;oBACAC;gBACF;YAEJ;YACA,IAAIa,MAAMC,OAAO,CAAC5B,OAAOkB,aAAa,CAACR,MAAMS,WAAW,EAAEU,SAAS;gBACjE,IAAI,CAAC7B,OAAOkB,aAAa,CAACR,MAAMS,WAAW,EAAEU,QAAQC,QAAQ;oBAC3D;gBACF;gBACAhC,oBAAoB;oBAClBG;oBACAC;oBACAuB,MAAMf,KAAKmB,MAAM,IAAI,CAAC;oBACtB1B;oBACAC;oBACAC;oBACAE;oBACAsB,QAAQ7B,OAAOkB,aAAa,CAACR,MAAMS,WAAW,EAAEU;oBAChDrB;oBACAC;oBACAE;oBACAC;oBACAC;oBACAC;oBACAiB,YAAYrB,KAAKmB,MAAM,IAAI,CAAC;gBAC9B;YACF;QACF;IACF;AACF,EAAC"}

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

@@ -1,5 +0,0 @@
-import type { NodeValidation } from '../types.js';
-import type { UploadFeatureProps } from './feature.server.js';
-import type { SerializedUploadNode } from './nodes/UploadNode.js';
-export declare const uploadValidation: (props: UploadFeatureProps) => NodeValidation<SerializedUploadNode>;
-//# sourceMappingURL=validate.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/upload/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAEjE,eAAO,MAAM,gBAAgB,UACpB,kBAAkB,KACxB,eAAe,oBAAoB,CA0DrC,CAAA"}