@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/populate/recurseNestedFields.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "recurseNestedFields", {
+    enumerable: true,
+    get: function() {
+        return recurseNestedFields;
+    }
+});
+const _types = require("payload/types");
+const _populate = require("./populate");
+const _richTextRelationshipPromise = require("./richTextRelationshipPromise");
+const recurseNestedFields = ({ afterReadPromises, currentDepth = 0, data, depth, fields, overrideAccess = false, promises, req, showHiddenFields })=>{
+    fields.forEach((field)=>{
+        if (field.type === 'relationship' || field.type === 'upload') {
+            if (field.type === 'relationship') {
+                if (field.hasMany && Array.isArray(data[field.name])) {
+                    if (Array.isArray(field.relationTo)) {
+                        data[field.name].forEach(({ relationTo, value }, i)=>{
+                            const collection = req.payload.collections[relationTo];
+                            if (collection) {
+                                promises.push((0, _populate.populate)({
+                                    id: value,
+                                    collection,
+                                    currentDepth,
+                                    data: data[field.name],
+                                    depth,
+                                    field,
+                                    key: i,
+                                    overrideAccess,
+                                    req,
+                                    showHiddenFields
+                                }));
+                            }
+                        });
+                    } else {
+                        data[field.name].forEach((id, i)=>{
+                            const collection = req.payload.collections[field.relationTo];
+                            if (collection) {
+                                promises.push((0, _populate.populate)({
+                                    id,
+                                    collection,
+                                    currentDepth,
+                                    data: data[field.name],
+                                    depth,
+                                    field,
+                                    key: i,
+                                    overrideAccess,
+                                    req,
+                                    showHiddenFields
+                                }));
+                            }
+                        });
+                    }
+                } else if (Array.isArray(field.relationTo) && data[field.name]?.value && data[field.name]?.relationTo) {
+                    const collection = req.payload.collections[data[field.name].relationTo];
+                    promises.push((0, _populate.populate)({
+                        id: data[field.name].value,
+                        collection,
+                        currentDepth,
+                        data: data[field.name],
+                        depth,
+                        field,
+                        key: 'value',
+                        overrideAccess,
+                        req,
+                        showHiddenFields
+                    }));
+                }
+            }
+            if (typeof data[field.name] !== 'undefined' && typeof field.relationTo === 'string') {
+                const collection = req.payload.collections[field.relationTo];
+                promises.push((0, _populate.populate)({
+                    id: data[field.name],
+                    collection,
+                    currentDepth,
+                    data,
+                    depth,
+                    field,
+                    key: field.name,
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+        } else if ((0, _types.fieldHasSubFields)(field) && !(0, _types.fieldIsArrayType)(field)) {
+            if ((0, _types.fieldAffectsData)(field) && typeof data[field.name] === 'object') {
+                recurseNestedFields({
+                    afterReadPromises,
+                    currentDepth,
+                    data: data[field.name],
+                    depth,
+                    fields: field.fields,
+                    overrideAccess,
+                    promises,
+                    req,
+                    showHiddenFields
+                });
+            } else {
+                recurseNestedFields({
+                    afterReadPromises,
+                    currentDepth,
+                    data,
+                    depth,
+                    fields: field.fields,
+                    overrideAccess,
+                    promises,
+                    req,
+                    showHiddenFields
+                });
+            }
+        } else if (field.type === 'tabs') {
+            field.tabs.forEach((tab)=>{
+                recurseNestedFields({
+                    afterReadPromises,
+                    currentDepth,
+                    data,
+                    depth,
+                    fields: tab.fields,
+                    overrideAccess,
+                    promises,
+                    req,
+                    showHiddenFields
+                });
+            });
+        } else if (Array.isArray(data[field.name])) {
+            if (field.type === 'blocks') {
+                data[field.name].forEach((row, i)=>{
+                    const block = field.blocks.find(({ slug })=>slug === row?.blockType);
+                    if (block) {
+                        recurseNestedFields({
+                            afterReadPromises,
+                            currentDepth,
+                            data: data[field.name][i],
+                            depth,
+                            fields: block.fields,
+                            overrideAccess,
+                            promises,
+                            req,
+                            showHiddenFields
+                        });
+                    }
+                });
+            }
+            if (field.type === 'array') {
+                data[field.name].forEach((_, i)=>{
+                    recurseNestedFields({
+                        afterReadPromises,
+                        currentDepth,
+                        data: data[field.name][i],
+                        depth,
+                        fields: field.fields,
+                        overrideAccess,
+                        promises,
+                        req,
+                        showHiddenFields
+                    });
+                });
+            }
+        }
+        if (field.type === 'richText' && Array.isArray(data[field.name])) {
+            data[field.name].root.children.forEach((node)=>{
+                if ('children' in node && Array.isArray(node.children)) {
+                    (0, _richTextRelationshipPromise.recurseRichText)({
+                        afterReadPromises,
+                        children: node.children,
+                        currentDepth,
+                        depth,
+                        field: field,
+                        overrideAccess,
+                        promises,
+                        req,
+                        showHiddenFields
+                    });
+                }
+            });
+        }
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/populate/recurseNestedFields.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, PayloadRequest, RichTextField } from 'payload/types'\n\nimport { fieldAffectsData, fieldHasSubFields, fieldIsArrayType } from 'payload/types'\n\nimport type { AfterReadPromise } from '../field/features/types'\nimport type { AdapterProps } from '../types'\n\nimport { populate } from './populate'\nimport { recurseRichText } from './richTextRelationshipPromise'\n\ntype NestedRichTextFieldsArgs = {\n  afterReadPromises: Map<string, Array<AfterReadPromise>>\n  currentDepth?: number\n  data: unknown\n  depth: number\n  fields: Field[]\n  overrideAccess: boolean\n  promises: Promise<void>[]\n  req: PayloadRequest\n  showHiddenFields: boolean\n}\n\nexport const recurseNestedFields = ({\n  afterReadPromises,\n  currentDepth = 0,\n  data,\n  depth,\n  fields,\n  overrideAccess = false,\n  promises,\n  req,\n  showHiddenFields,\n}: NestedRichTextFieldsArgs): void => {\n  fields.forEach((field) => {\n    if (field.type === 'relationship' || field.type === 'upload') {\n      if (field.type === 'relationship') {\n        if (field.hasMany && Array.isArray(data[field.name])) {\n          if (Array.isArray(field.relationTo)) {\n            data[field.name].forEach(({ relationTo, value }, i) => {\n              const collection = req.payload.collections[relationTo]\n              if (collection) {\n                promises.push(\n                  populate({\n                    id: value,\n                    collection,\n                    currentDepth,\n                    data: data[field.name],\n                    depth,\n                    field,\n                    key: i,\n                    overrideAccess,\n                    req,\n                    showHiddenFields,\n                  }),\n                )\n              }\n            })\n          } else {\n            data[field.name].forEach((id, i) => {\n              const collection = req.payload.collections[field.relationTo as string]\n              if (collection) {\n                promises.push(\n                  populate({\n                    id,\n                    collection,\n                    currentDepth,\n                    data: data[field.name],\n                    depth,\n                    field,\n                    key: i,\n                    overrideAccess,\n                    req,\n                    showHiddenFields,\n                  }),\n                )\n              }\n            })\n          }\n        } else if (\n          Array.isArray(field.relationTo) &&\n          data[field.name]?.value &&\n          data[field.name]?.relationTo\n        ) {\n          const collection = req.payload.collections[data[field.name].relationTo]\n          promises.push(\n            populate({\n              id: data[field.name].value,\n              collection,\n              currentDepth,\n              data: data[field.name],\n              depth,\n              field,\n              key: 'value',\n              overrideAccess,\n              req,\n              showHiddenFields,\n            }),\n          )\n        }\n      }\n      if (typeof data[field.name] !== 'undefined' && typeof field.relationTo === 'string') {\n        const collection = req.payload.collections[field.relationTo]\n        promises.push(\n          populate({\n            id: data[field.name],\n            collection,\n            currentDepth,\n            data,\n            depth,\n            field,\n            key: field.name,\n            overrideAccess,\n            req,\n            showHiddenFields,\n          }),\n        )\n      }\n    } else if (fieldHasSubFields(field) && !fieldIsArrayType(field)) {\n      if (fieldAffectsData(field) && typeof data[field.name] === 'object') {\n        recurseNestedFields({\n          afterReadPromises,\n          currentDepth,\n          data: data[field.name],\n          depth,\n          fields: field.fields,\n          overrideAccess,\n          promises,\n          req,\n          showHiddenFields,\n        })\n      } else {\n        recurseNestedFields({\n          afterReadPromises,\n          currentDepth,\n          data,\n          depth,\n          fields: field.fields,\n          overrideAccess,\n          promises,\n          req,\n          showHiddenFields,\n        })\n      }\n    } else if (field.type === 'tabs') {\n      field.tabs.forEach((tab) => {\n        recurseNestedFields({\n          afterReadPromises,\n          currentDepth,\n          data,\n          depth,\n          fields: tab.fields,\n          overrideAccess,\n          promises,\n          req,\n          showHiddenFields,\n        })\n      })\n    } else if (Array.isArray(data[field.name])) {\n      if (field.type === 'blocks') {\n        data[field.name].forEach((row, i) => {\n          const block = field.blocks.find(({ slug }) => slug === row?.blockType)\n          if (block) {\n            recurseNestedFields({\n              afterReadPromises,\n              currentDepth,\n              data: data[field.name][i],\n              depth,\n              fields: block.fields,\n              overrideAccess,\n              promises,\n              req,\n              showHiddenFields,\n            })\n          }\n        })\n      }\n\n      if (field.type === 'array') {\n        data[field.name].forEach((_, i) => {\n          recurseNestedFields({\n            afterReadPromises,\n            currentDepth,\n            data: data[field.name][i],\n            depth,\n            fields: field.fields,\n            overrideAccess,\n            promises,\n            req,\n            showHiddenFields,\n          })\n        })\n      }\n    }\n\n    if (field.type === 'richText' && Array.isArray(data[field.name])) {\n      ;(data[field.name] as SerializedEditorState).root.children.forEach((node) => {\n        if ('children' in node && Array.isArray(node.children)) {\n          recurseRichText({\n            afterReadPromises,\n            children: node.children,\n            currentDepth,\n            depth,\n            field: field as RichTextField<AdapterProps>,\n            overrideAccess,\n            promises,\n            req,\n            showHiddenFields,\n          })\n        }\n      })\n    }\n  })\n}\n"],"names":["recurseNestedFields","afterReadPromises","currentDepth","data","depth","fields","overrideAccess","promises","req","showHiddenFields","forEach","field","type","hasMany","Array","isArray","name","relationTo","value","i","collection","payload","collections","push","populate","id","key","fieldHasSubFields","fieldIsArrayType","fieldAffectsData","tabs","tab","row","block","blocks","find","slug","blockType","_","root","children","node","recurseRichText"],"mappings":";;;;+BAuBaA;;;eAAAA;;;uBApByD;0BAK7C;6CACO;AAczB,MAAMA,sBAAsB,CAAC,EAClCC,iBAAiB,EACjBC,eAAe,CAAC,EAChBC,IAAI,EACJC,KAAK,EACLC,MAAM,EACNC,iBAAiB,KAAK,EACtBC,QAAQ,EACRC,GAAG,EACHC,gBAAgB,EACS;IACzBJ,OAAOK,OAAO,CAAC,CAACC;QACd,IAAIA,MAAMC,IAAI,KAAK,kBAAkBD,MAAMC,IAAI,KAAK,UAAU;YAC5D,IAAID,MAAMC,IAAI,KAAK,gBAAgB;gBACjC,IAAID,MAAME,OAAO,IAAIC,MAAMC,OAAO,CAACZ,IAAI,CAACQ,MAAMK,IAAI,CAAC,GAAG;oBACpD,IAAIF,MAAMC,OAAO,CAACJ,MAAMM,UAAU,GAAG;wBACnCd,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACN,OAAO,CAAC,CAAC,EAAEO,UAAU,EAAEC,KAAK,EAAE,EAAEC;4BAC/C,MAAMC,aAAaZ,IAAIa,OAAO,CAACC,WAAW,CAACL,WAAW;4BACtD,IAAIG,YAAY;gCACdb,SAASgB,IAAI,CACXC,IAAAA,kBAAQ,EAAC;oCACPC,IAAIP;oCACJE;oCACAlB;oCACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC;oCACtBZ;oCACAO;oCACAe,KAAKP;oCACLb;oCACAE;oCACAC;gCACF;4BAEJ;wBACF;oBACF,OAAO;wBACLN,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACN,OAAO,CAAC,CAACe,IAAIN;4BAC5B,MAAMC,aAAaZ,IAAIa,OAAO,CAACC,WAAW,CAACX,MAAMM,UAAU,CAAW;4BACtE,IAAIG,YAAY;gCACdb,SAASgB,IAAI,CACXC,IAAAA,kBAAQ,EAAC;oCACPC;oCACAL;oCACAlB;oCACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC;oCACtBZ;oCACAO;oCACAe,KAAKP;oCACLb;oCACAE;oCACAC;gCACF;4BAEJ;wBACF;oBACF;gBACF,OAAO,IACLK,MAAMC,OAAO,CAACJ,MAAMM,UAAU,KAC9Bd,IAAI,CAACQ,MAAMK,IAAI,CAAC,EAAEE,SAClBf,IAAI,CAACQ,MAAMK,IAAI,CAAC,EAAEC,YAClB;oBACA,MAAMG,aAAaZ,IAAIa,OAAO,CAACC,WAAW,CAACnB,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACC,UAAU,CAAC;oBACvEV,SAASgB,IAAI,CACXC,IAAAA,kBAAQ,EAAC;wBACPC,IAAItB,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACE,KAAK;wBAC1BE;wBACAlB;wBACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC;wBACtBZ;wBACAO;wBACAe,KAAK;wBACLpB;wBACAE;wBACAC;oBACF;gBAEJ;YACF;YACA,IAAI,OAAON,IAAI,CAACQ,MAAMK,IAAI,CAAC,KAAK,eAAe,OAAOL,MAAMM,UAAU,KAAK,UAAU;gBACnF,MAAMG,aAAaZ,IAAIa,OAAO,CAACC,WAAW,CAACX,MAAMM,UAAU,CAAC;gBAC5DV,SAASgB,IAAI,CACXC,IAAAA,kBAAQ,EAAC;oBACPC,IAAItB,IAAI,CAACQ,MAAMK,IAAI,CAAC;oBACpBI;oBACAlB;oBACAC;oBACAC;oBACAO;oBACAe,KAAKf,MAAMK,IAAI;oBACfV;oBACAE;oBACAC;gBACF;YAEJ;QACF,OAAO,IAAIkB,IAAAA,wBAAiB,EAAChB,UAAU,CAACiB,IAAAA,uBAAgB,EAACjB,QAAQ;YAC/D,IAAIkB,IAAAA,uBAAgB,EAAClB,UAAU,OAAOR,IAAI,CAACQ,MAAMK,IAAI,CAAC,KAAK,UAAU;gBACnEhB,oBAAoB;oBAClBC;oBACAC;oBACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC;oBACtBZ;oBACAC,QAAQM,MAAMN,MAAM;oBACpBC;oBACAC;oBACAC;oBACAC;gBACF;YACF,OAAO;gBACLT,oBAAoB;oBAClBC;oBACAC;oBACAC;oBACAC;oBACAC,QAAQM,MAAMN,MAAM;oBACpBC;oBACAC;oBACAC;oBACAC;gBACF;YACF;QACF,OAAO,IAAIE,MAAMC,IAAI,KAAK,QAAQ;YAChCD,MAAMmB,IAAI,CAACpB,OAAO,CAAC,CAACqB;gBAClB/B,oBAAoB;oBAClBC;oBACAC;oBACAC;oBACAC;oBACAC,QAAQ0B,IAAI1B,MAAM;oBAClBC;oBACAC;oBACAC;oBACAC;gBACF;YACF;QACF,OAAO,IAAIK,MAAMC,OAAO,CAACZ,IAAI,CAACQ,MAAMK,IAAI,CAAC,GAAG;YAC1C,IAAIL,MAAMC,IAAI,KAAK,UAAU;gBAC3BT,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACN,OAAO,CAAC,CAACsB,KAAKb;oBAC7B,MAAMc,QAAQtB,MAAMuB,MAAM,CAACC,IAAI,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA,SAASJ,KAAKK;oBAC5D,IAAIJ,OAAO;wBACTjC,oBAAoB;4BAClBC;4BACAC;4BACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACG,EAAE;4BACzBf;4BACAC,QAAQ4B,MAAM5B,MAAM;4BACpBC;4BACAC;4BACAC;4BACAC;wBACF;oBACF;gBACF;YACF;YAEA,IAAIE,MAAMC,IAAI,KAAK,SAAS;gBAC1BT,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACN,OAAO,CAAC,CAAC4B,GAAGnB;oBAC3BnB,oBAAoB;wBAClBC;wBACAC;wBACAC,MAAMA,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAACG,EAAE;wBACzBf;wBACAC,QAAQM,MAAMN,MAAM;wBACpBC;wBACAC;wBACAC;wBACAC;oBACF;gBACF;YACF;QACF;QAEA,IAAIE,MAAMC,IAAI,KAAK,cAAcE,MAAMC,OAAO,CAACZ,IAAI,CAACQ,MAAMK,IAAI,CAAC,GAAG;YAC9Db,IAAI,CAACQ,MAAMK,IAAI,CAAC,CAA2BuB,IAAI,CAACC,QAAQ,CAAC9B,OAAO,CAAC,CAAC+B;gBAClE,IAAI,cAAcA,QAAQ3B,MAAMC,OAAO,CAAC0B,KAAKD,QAAQ,GAAG;oBACtDE,IAAAA,4CAAe,EAAC;wBACdzC;wBACAuC,UAAUC,KAAKD,QAAQ;wBACvBtC;wBACAE;wBACAO,OAAOA;wBACPL;wBACAC;wBACAC;wBACAC;oBACF;gBACF;YACF;QACF;IACF;AACF"}

package/dist/populate/richTextRelationshipPromise.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { PayloadRequest, RichTextAdapter, RichTextField } from 'payload/types';
+import type { AfterReadPromise } from '../field/features/types';
+import type { AdapterProps } from '../types';
+export type Args = Parameters<RichTextAdapter<AdapterProps>['afterReadPromise']>[0] & {
+    afterReadPromises: Map<string, Array<AfterReadPromise>>;
+};
+type RecurseRichTextArgs = {
+    afterReadPromises: Map<string, Array<AfterReadPromise>>;
+    children: SerializedLexicalNode[];
+    currentDepth: number;
+    depth: number;
+    field: RichTextField<AdapterProps>;
+    overrideAccess: boolean;
+    promises: Promise<void>[];
+    req: PayloadRequest;
+    showHiddenFields: boolean;
+};
+export declare const recurseRichText: ({ afterReadPromises, children, currentDepth, depth, field, overrideAccess, promises, req, showHiddenFields, }: RecurseRichTextArgs) => void;
+export declare const richTextRelationshipPromise: ({ afterReadPromises, currentDepth, depth, field, overrideAccess, req, showHiddenFields, siblingDoc, }: Args) => Promise<void>;
+export {};
+//# sourceMappingURL=richTextRelationshipPromise.d.ts.map

package/dist/populate/richTextRelationshipPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"richTextRelationshipPromise.d.ts","sourceRoot":"","sources":["../../src/populate/richTextRelationshipPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyB,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAEnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;IACpF,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAA;CACxD,CAAA;AAED,KAAK,mBAAmB,GAAG;IACzB,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAA;IACvD,QAAQ,EAAE,qBAAqB,EAAE,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IAClC,cAAc,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,eAAe,kHAUzB,mBAAmB,KAAG,IAuCxB,CAAA;AAED,eAAO,MAAM,2BAA2B,0GASrC,IAAI,KAAG,QAAQ,IAAI,CAgBrB,CAAA"}

package/dist/populate/richTextRelationshipPromise.js

@@ -0,0 +1,71 @@
+"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, {
+    recurseRichText: function() {
+        return recurseRichText;
+    },
+    richTextRelationshipPromise: function() {
+        return richTextRelationshipPromise;
+    }
+});
+const recurseRichText = ({ afterReadPromises, children, currentDepth = 0, depth, field, overrideAccess = false, promises, req, showHiddenFields })=>{
+    if (depth <= 0 || currentDepth > depth) {
+        return;
+    }
+    if (Array.isArray(children)) {
+        children.forEach((node)=>{
+            if (afterReadPromises?.has(node.type)) {
+                for (const promise of afterReadPromises.get(node.type)){
+                    promises.push(...promise({
+                        afterReadPromises,
+                        currentDepth,
+                        depth,
+                        field,
+                        node: node,
+                        overrideAccess,
+                        req,
+                        showHiddenFields
+                    }));
+                }
+            }
+            if ('children' in node && node?.children) {
+                recurseRichText({
+                    afterReadPromises,
+                    children: node.children,
+                    currentDepth,
+                    depth,
+                    field,
+                    overrideAccess,
+                    promises,
+                    req,
+                    showHiddenFields
+                });
+            }
+        });
+    }
+};
+const richTextRelationshipPromise = async ({ afterReadPromises, currentDepth, depth, field, overrideAccess, req, showHiddenFields, siblingDoc })=>{
+    const promises = [];
+    recurseRichText({
+        afterReadPromises,
+        children: siblingDoc[field?.name]?.root?.children ?? [],
+        currentDepth,
+        depth,
+        field,
+        overrideAccess,
+        promises,
+        req,
+        showHiddenFields
+    });
+    await Promise.all(promises);
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/populate/validation.d.ts

@@ -0,0 +1,4 @@
+import type { RichTextField, Validate } from 'payload/types';
+import type { AdapterProps } from '../types';
+export declare const richTextValidate: Validate<unknown, unknown, RichTextField<AdapterProps>>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/populate/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/populate/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAI5C,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAWpF,CAAA"}

package/dist/populate/validation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "richTextValidate", {
+    enumerable: true,
+    get: function() {
+        return richTextValidate;
+    }
+});
+const _defaultValue = require("./defaultValue");
+const richTextValidate = (value, { required, t })=>{
+    if (required) {
+        const stringifiedDefaultValue = JSON.stringify(_defaultValue.defaultRichTextValue);
+        if (value && JSON.stringify(value) !== stringifiedDefaultValue) return true;
+        return t('validation:required');
+    }
+    return true;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wb3B1bGF0ZS92YWxpZGF0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmljaFRleHRGaWVsZCwgVmFsaWRhdGUgfSBmcm9tICdwYXlsb2FkL3R5cGVzJ1xuXG5pbXBvcnQgdHlwZSB7IEFkYXB0ZXJQcm9wcyB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBkZWZhdWx0UmljaFRleHRWYWx1ZSB9IGZyb20gJy4vZGVmYXVsdFZhbHVlJ1xuXG5leHBvcnQgY29uc3QgcmljaFRleHRWYWxpZGF0ZTogVmFsaWRhdGU8dW5rbm93biwgdW5rbm93biwgUmljaFRleHRGaWVsZDxBZGFwdGVyUHJvcHM+PiA9IChcbiAgdmFsdWUsXG4gIHsgcmVxdWlyZWQsIHQgfSxcbikgPT4ge1xuICBpZiAocmVxdWlyZWQpIHtcbiAgICBjb25zdCBzdHJpbmdpZmllZERlZmF1bHRWYWx1ZSA9IEpTT04uc3RyaW5naWZ5KGRlZmF1bHRSaWNoVGV4dFZhbHVlKVxuICAgIGlmICh2YWx1ZSAmJiBKU09OLnN0cmluZ2lmeSh2YWx1ZSkgIT09IHN0cmluZ2lmaWVkRGVmYXVsdFZhbHVlKSByZXR1cm4gdHJ1ZVxuICAgIHJldHVybiB0KCd2YWxpZGF0aW9uOnJlcXVpcmVkJylcbiAgfVxuXG4gIHJldHVybiB0cnVlXG59XG4iXSwibmFtZXMiOlsicmljaFRleHRWYWxpZGF0ZSIsInZhbHVlIiwicmVxdWlyZWQiLCJ0Iiwic3RyaW5naWZpZWREZWZhdWx0VmFsdWUiLCJKU09OIiwic3RyaW5naWZ5IiwiZGVmYXVsdFJpY2hUZXh0VmFsdWUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBTWFBOzs7ZUFBQUE7Ozs4QkFGd0I7QUFFOUIsTUFBTUEsbUJBQTRFLENBQ3ZGQyxPQUNBLEVBQUVDLFFBQVEsRUFBRUMsQ0FBQyxFQUFFO0lBRWYsSUFBSUQsVUFBVTtRQUNaLE1BQU1FLDBCQUEwQkMsS0FBS0MsU0FBUyxDQUFDQyxrQ0FBb0I7UUFDbkUsSUFBSU4sU0FBU0ksS0FBS0MsU0FBUyxDQUFDTCxXQUFXRyx5QkFBeUIsT0FBTztRQUN2RSxPQUFPRCxFQUFFO0lBQ1g7SUFFQSxPQUFPO0FBQ1QifQ==

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import type { FieldPermissions } from 'payload/auth';
+import type { FieldTypes } from 'payload/config';
+import type { RichTextFieldProps } from 'payload/types';
+import type { SanitizedEditorConfig } from './field/lexical/config/types';
+export type FieldProps = RichTextFieldProps<AdapterProps> & {
+    fieldTypes: FieldTypes;
+    indexPath: string;
+    path?: string;
+    permissions: FieldPermissions;
+};
+export type AdapterProps = {
+    editorConfig: SanitizedEditorConfig;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAA;AAEzE,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,YAAY,CAAC,GAAG;IAC1D,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,gBAAgB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,qBAAqB,CAAA;CACpC,CAAA"}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@payloadcms/richtext-lexical",
+  "version": "0.1.0-beta.0",
+  "description": "The officially supported Lexical richtext adapter for Payload",
+  "repository": "https://github.com/payloadcms/payload",
+  "license": "MIT",
+  "homepage": "https://payloadcms.com",
+  "author": "Payload CMS, Inc.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@faceless-ui/modal": "2.0.1",
+    "@lexical/clipboard": "0.12.2",
+    "@lexical/code": "0.12.2",
+    "@lexical/file": "0.12.2",
+    "@lexical/hashtag": "0.12.2",
+    "@lexical/headless": "0.12.2",
+    "@lexical/html": "0.12.2",
+    "@lexical/link": "0.12.2",
+    "@lexical/list": "0.12.2",
+    "@lexical/mark": "0.12.2",
+    "@lexical/markdown": "0.12.2",
+    "@lexical/overflow": "0.12.2",
+    "@lexical/plain-text": "0.12.2",
+    "@lexical/react": "0.12.2",
+    "@lexical/rich-text": "0.12.2",
+    "@lexical/selection": "0.12.2",
+    "@lexical/table": "0.12.2",
+    "@lexical/utils": "0.12.2",
+    "classnames": "^2.3.2",
+    "i18next": "22.5.1",
+    "katex": "0.16.8",
+    "lexical": "0.12.2",
+    "lodash": "4.17.21",
+    "openai": "4.7.1",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-error-boundary": "^4.0.11",
+    "react-i18next": "11.18.6",
+    "ts-essentials": "7.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "20.6.2",
+    "@types/react": "18.2.15",
+    "payload": "2.0.0-beta.1",
+    "@payloadcms/eslint-config": "0.0.1"
+  },
+  "exports": null,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm build:swc && pnpm build:types",
+    "build:swc": "swc ./src -d ./dist --config-file .swcrc",
+    "build:types": "tsc --emitDeclarationOnly --outDir dist"
+  }
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+import type { RichTextAdapter } from 'payload/types'
+
+import { withMergedProps } from 'payload/components/utilities'
+
+import type { EditorConfig, SanitizedEditorConfig } from './field/lexical/config/types'
+import type { AdapterProps } from './types'
+
+import { RichTextCell } from './cell'
+import { RichTextField } from './field'
+import { defaultEditorConfig, defaultSanitizedEditorConfig } from './field/lexical/config/default'
+import { sanitizeEditorConfig } from './field/lexical/config/sanitize'
+import { cloneDeep } from './field/lexical/utils/cloneDeep'
+import { richTextRelationshipPromise } from './populate/richTextRelationshipPromise'
+
+export function createLexical({
+  userConfig,
+}: {
+  userConfig?: (defaultEditorConfig: EditorConfig) => EditorConfig
+}): RichTextAdapter<AdapterProps> {
+  const finalSanitizedEditorConfig: SanitizedEditorConfig =
+    userConfig == null || typeof userConfig != 'function'
+      ? cloneDeep(defaultSanitizedEditorConfig)
+      : sanitizeEditorConfig(userConfig(cloneDeep(defaultEditorConfig)))
+
+  return {
+    CellComponent: withMergedProps({
+      Component: RichTextCell,
+      toMergeIntoProps: { editorConfig: finalSanitizedEditorConfig },
+    }),
+    FieldComponent: withMergedProps({
+      Component: RichTextField,
+      toMergeIntoProps: { editorConfig: finalSanitizedEditorConfig },
+    }),
+    afterReadPromise({
+      currentDepth,
+      depth,
+      field,
+      overrideAccess,
+      req,
+      showHiddenFields,
+      siblingDoc,
+    }) {
+      // check if there are any features with nodes which have afterReadPromises for this field
+      if (finalSanitizedEditorConfig?.features?.afterReadPromises?.size) {
+        return richTextRelationshipPromise({
+          afterReadPromises: finalSanitizedEditorConfig.features.afterReadPromises,
+          currentDepth,
+          depth,
+          field,
+          overrideAccess,
+          req,
+          showHiddenFields,
+          siblingDoc,
+        })
+      }
+
+      return null
+    },
+  }
+}
+
+export { BlockQuoteFeature } from './field/features/BlockQuote'
+export { BlocksFeature } from './field/features/Blocks'
+export { HeadingFeature } from './field/features/Heading'
+export { LinkFeature, LinkFeatureProps } from './field/features/Link'
+export { ParagraphFeature } from './field/features/Paragraph'
+export { RelationshipFeature } from './field/features/Relationship'
+export { UploadFeature, UploadFeatureProps } from './field/features/Upload'
+export { AlignFeature } from './field/features/align'
+export { TextDropdownSectionWithEntries } from './field/features/common/floatingSelectToolbarTextDropdownSection'
+export { TreeviewFeature } from './field/features/debug/TreeView'
+export { BoldTextFeature } from './field/features/format/Bold'
+export { InlineCodeTextFeature } from './field/features/format/InlineCode'
+export { ItalicTextFeature } from './field/features/format/Italic'
+export { SectionWithEntries as FormatSectionWithEntries } from './field/features/format/common/floatingSelectToolbarSection'
+export { StrikethroughTextFeature } from './field/features/format/strikethrough'
+export { SubscriptTextFeature } from './field/features/format/subscript'
+export { SuperscriptTextFeature } from './field/features/format/superscript'
+export { UnderlineTextFeature } from './field/features/format/underline'
+export { IndentFeature } from './field/features/indent'
+export { CheckListFeature } from './field/features/lists/CheckList'
+export { OrderedListFeature } from './field/features/lists/OrderedList'
+export { UnoderedListFeature } from './field/features/lists/UnorderedList'
+
+export {
+  Feature,
+  FeatureProvider,
+  FeatureProviderMap,
+  ResolvedFeature,
+  ResolvedFeatureMap,
+  SanitizedFeatures,
+} from './field/features/types'