@payloadcms/richtext-lexical 3.0.0-beta.6 → 3.0.0-beta.60

package/dist/utilities/migrateSlateToLexical/index.js

@@ -0,0 +1,105 @@
+import { migrateDocumentFieldsRecursively } from './migrateDocumentFieldsRecursively.js';
+/**
+ * This goes through every single collection and field in the payload config, and migrates its data from Slate to Lexical. This does not support sub-fields within slate.
+ *
+ * It will only translate fields fulfilling all these requirements:
+ * - field schema uses lexical editor
+ * - lexical editor has SlateToLexicalFeature added
+ * - saved field data is in Slate format
+ *
+ * @param payload
+ */ export async function migrateSlateToLexical({ payload }) {
+    const collections = payload.config.collections;
+    const allLocales = payload.config.localization ? payload.config.localization.localeCodes : [
+        null
+    ];
+    const totalCollections = collections.length;
+    for (const locale of allLocales){
+        let curCollection = 0;
+        for (const collection of collections){
+            curCollection++;
+            await migrateCollection({
+                collection,
+                cur: curCollection,
+                locale,
+                max: totalCollections,
+                payload
+            });
+        }
+        for (const global of payload.config.globals){
+            await migrateGlobal({
+                global,
+                locale,
+                payload
+            });
+        }
+    }
+}
+async function migrateGlobal({ global, locale, payload }) {
+    console.log(`SlateToLexical: ${locale}: Migrating global:`, global.slug);
+    const document = await payload.findGlobal({
+        slug: global.slug,
+        depth: 0,
+        locale: locale || undefined,
+        overrideAccess: true
+    });
+    const found = migrateDocument({
+        document,
+        fields: global.fields
+    });
+    if (found) {
+        await payload.updateGlobal({
+            slug: global.slug,
+            data: document,
+            depth: 0,
+            locale: locale || undefined
+        });
+    }
+}
+async function migrateCollection({ collection, cur, locale, max, payload }) {
+    console.log(`SlateToLexical: ${locale}: Migrating collection:`, collection.slug, '(' + cur + '/' + max + ')');
+    const documentCount = (await payload.count({
+        collection: collection.slug,
+        depth: 0,
+        locale: locale || undefined
+    })).totalDocs;
+    let page = 1;
+    let migrated = 0;
+    while(migrated < documentCount){
+        const documents = await payload.find({
+            collection: collection.slug,
+            depth: 0,
+            locale: locale || undefined,
+            overrideAccess: true,
+            page,
+            pagination: true
+        });
+        for (const document of documents.docs){
+            migrated++;
+            console.log(`SlateToLexical: ${locale}: Migrating collection:`, collection.slug, '(' + cur + '/' + max + ') - Migrating Document: ' + document.id + ' (' + migrated + '/' + documentCount + ')');
+            const found = migrateDocument({
+                document,
+                fields: collection.fields
+            });
+            if (found) {
+                await payload.update({
+                    id: document.id,
+                    collection: collection.slug,
+                    data: document,
+                    depth: 0,
+                    locale: locale || undefined
+                });
+            }
+        }
+        page++;
+    }
+}
+function migrateDocument({ document, fields }) {
+    return !!migrateDocumentFieldsRecursively({
+        data: document,
+        fields,
+        found: 0
+    });
+}
+
+//# sourceMappingURL=index.js.map

package/dist/utilities/migrateSlateToLexical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/migrateSlateToLexical/index.ts"],"sourcesContent":["import type { CollectionConfig, Field, GlobalConfig, Payload } from 'payload'\n\nimport { migrateDocumentFieldsRecursively } from './migrateDocumentFieldsRecursively.js'\n\n/**\n * This goes through every single collection and field in the payload config, and migrates its data from Slate to Lexical. This does not support sub-fields within slate.\n *\n * It will only translate fields fulfilling all these requirements:\n * - field schema uses lexical editor\n * - lexical editor has SlateToLexicalFeature added\n * - saved field data is in Slate format\n *\n * @param payload\n */\nexport async function migrateSlateToLexical({ payload }: { payload: Payload }) {\n  const collections = payload.config.collections\n\n  const allLocales = payload.config.localization ? payload.config.localization.localeCodes : [null]\n\n  const totalCollections = collections.length\n  for (const locale of allLocales) {\n    let curCollection = 0\n    for (const collection of collections) {\n      curCollection++\n      await migrateCollection({\n        collection,\n        cur: curCollection,\n        locale,\n        max: totalCollections,\n        payload,\n      })\n    }\n    for (const global of payload.config.globals) {\n      await migrateGlobal({\n        global,\n        locale,\n        payload,\n      })\n    }\n  }\n}\n\nasync function migrateGlobal({\n  global,\n  locale,\n  payload,\n}: {\n  global: GlobalConfig\n  locale: null | string\n  payload: Payload\n}) {\n  console.log(`SlateToLexical: ${locale}: Migrating global:`, global.slug)\n\n  const document = await payload.findGlobal({\n    slug: global.slug,\n    depth: 0,\n    locale: locale || undefined,\n    overrideAccess: true,\n  })\n\n  const found = migrateDocument({\n    document,\n    fields: global.fields,\n  })\n\n  if (found) {\n    await payload.updateGlobal({\n      slug: global.slug,\n      data: document,\n      depth: 0,\n      locale: locale || undefined,\n    })\n  }\n}\n\nasync function migrateCollection({\n  collection,\n  cur,\n  locale,\n  max,\n  payload,\n}: {\n  collection: CollectionConfig\n  cur: number\n  locale: null | string\n  max: number\n  payload: Payload\n}) {\n  console.log(\n    `SlateToLexical: ${locale}: Migrating collection:`,\n    collection.slug,\n    '(' + cur + '/' + max + ')',\n  )\n\n  const documentCount = (\n    await payload.count({\n      collection: collection.slug,\n      depth: 0,\n      locale: locale || undefined,\n    })\n  ).totalDocs\n\n  let page = 1\n  let migrated = 0\n\n  while (migrated < documentCount) {\n    const documents = await payload.find({\n      collection: collection.slug,\n      depth: 0,\n      locale: locale || undefined,\n      overrideAccess: true,\n      page,\n      pagination: true,\n    })\n\n    for (const document of documents.docs) {\n      migrated++\n      console.log(\n        `SlateToLexical: ${locale}: Migrating collection:`,\n        collection.slug,\n        '(' +\n          cur +\n          '/' +\n          max +\n          ') - Migrating Document: ' +\n          document.id +\n          ' (' +\n          migrated +\n          '/' +\n          documentCount +\n          ')',\n      )\n      const found = migrateDocument({\n        document,\n        fields: collection.fields,\n      })\n\n      if (found) {\n        await payload.update({\n          id: document.id,\n          collection: collection.slug,\n          data: document,\n          depth: 0,\n          locale: locale || undefined,\n        })\n      }\n    }\n    page++\n  }\n}\n\nfunction migrateDocument({\n  document,\n  fields,\n}: {\n  document: Record<string, unknown>\n  fields: Field[]\n}): boolean {\n  return !!migrateDocumentFieldsRecursively({\n    data: document,\n    fields,\n    found: 0,\n  })\n}\n"],"names":["migrateDocumentFieldsRecursively","migrateSlateToLexical","payload","collections","config","allLocales","localization","localeCodes","totalCollections","length","locale","curCollection","collection","migrateCollection","cur","max","global","globals","migrateGlobal","console","log","slug","document","findGlobal","depth","undefined","overrideAccess","found","migrateDocument","fields","updateGlobal","data","documentCount","count","totalDocs","page","migrated","documents","find","pagination","docs","id","update"],"mappings":"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"}

package/dist/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.d.ts

@@ -0,0 +1,9 @@
+import type { Field } from 'payload';
+type NestedRichTextFieldsArgs = {
+    data: unknown;
+    fields: Field[];
+    found: number;
+};
+export declare const migrateDocumentFieldsRecursively: ({ data, fields, found, }: NestedRichTextFieldsArgs) => number;
+export {};
+//# sourceMappingURL=migrateDocumentFieldsRecursively.d.ts.map

package/dist/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateDocumentFieldsRecursively.d.ts","sourceRoot":"","sources":["../../../src/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAYpC,KAAK,wBAAwB,GAAG;IAC9B,IAAI,EAAE,OAAO,CAAA;IAEb,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,gCAAgC,6BAI1C,wBAAwB,KAAG,MAwF7B,CAAA"}

package/dist/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.js

@@ -0,0 +1,77 @@
+import { fieldAffectsData, fieldHasSubFields, fieldIsArrayType } from 'payload/shared';
+import { convertSlateToLexical } from '../../features/migrations/slateToLexical/converter/index.js';
+export const migrateDocumentFieldsRecursively = ({ data, fields, found })=>{
+    for (const field of fields){
+        if (fieldHasSubFields(field) && !fieldIsArrayType(field)) {
+            if (fieldAffectsData(field) && typeof data[field.name] === 'object') {
+                migrateDocumentFieldsRecursively({
+                    data: data[field.name],
+                    fields: field.fields,
+                    found
+                });
+            } else {
+                migrateDocumentFieldsRecursively({
+                    data,
+                    found,
+                    fields: field.fields
+                });
+            }
+        } else if (field.type === 'tabs') {
+            field.tabs.forEach((tab)=>{
+                migrateDocumentFieldsRecursively({
+                    data,
+                    found,
+                    fields: tab.fields
+                });
+            });
+        } 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) {
+                        migrateDocumentFieldsRecursively({
+                            data: data[field.name][i],
+                            found,
+                            fields: block.fields
+                        });
+                    }
+                });
+            }
+            if (field.type === 'array') {
+                data[field.name].forEach((_, i)=>{
+                    migrateDocumentFieldsRecursively({
+                        data: data[field.name][i],
+                        found,
+                        fields: field.fields
+                    });
+                });
+            }
+        }
+        if (field.type === 'richText' && Array.isArray(data[field.name])) {
+            // Slate richText
+            const editor = field.editor;
+            if (editor && typeof editor === 'object') {
+                if ('features' in editor && editor.features?.length) {
+                    // find slatetolexical feature
+                    const slateToLexicalFeature = editor.editorConfig.resolvedFeatureMap.get('slateToLexical');
+                    if (slateToLexicalFeature) {
+                        // DO CONVERSION
+                        const converterProviders = slateToLexicalFeature.sanitizedServerFeatureProps.converters;
+                        const converters = [];
+                        for (const converter of converterProviders){
+                            converters.push(converter.converter);
+                        }
+                        data[field.name] = convertSlateToLexical({
+                            converters,
+                            slateData: data[field.name]
+                        });
+                        found++;
+                    }
+                }
+            }
+        }
+    }
+    return found;
+};
+
+//# sourceMappingURL=migrateDocumentFieldsRecursively.js.map

package/dist/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.ts"],"sourcesContent":["import type { Field } from 'payload'\n\nimport { fieldAffectsData, fieldHasSubFields, fieldIsArrayType } from 'payload/shared'\n\nimport type {\n  SlateNodeConverter,\n  SlateNodeConverterProvider,\n} from '../../features/migrations/slateToLexical/converter/types.js'\nimport type { LexicalRichTextAdapter } from '../../types.js'\n\nimport { convertSlateToLexical } from '../../features/migrations/slateToLexical/converter/index.js'\n\ntype NestedRichTextFieldsArgs = {\n  data: unknown\n\n  fields: Field[]\n  found: number\n}\n\nexport const migrateDocumentFieldsRecursively = ({\n  data,\n  fields,\n  found,\n}: NestedRichTextFieldsArgs): number => {\n  for (const field of fields) {\n    if (fieldHasSubFields(field) && !fieldIsArrayType(field)) {\n      if (fieldAffectsData(field) && typeof data[field.name] === 'object') {\n        migrateDocumentFieldsRecursively({\n          data: data[field.name],\n          fields: field.fields,\n          found,\n        })\n      } else {\n        migrateDocumentFieldsRecursively({\n          data,\n          found,\n\n          fields: field.fields,\n        })\n      }\n    } else if (field.type === 'tabs') {\n      field.tabs.forEach((tab) => {\n        migrateDocumentFieldsRecursively({\n          data,\n          found,\n\n          fields: tab.fields,\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            migrateDocumentFieldsRecursively({\n              data: data[field.name][i],\n              found,\n\n              fields: block.fields,\n            })\n          }\n        })\n      }\n\n      if (field.type === 'array') {\n        data[field.name].forEach((_, i) => {\n          migrateDocumentFieldsRecursively({\n            data: data[field.name][i],\n            found,\n\n            fields: field.fields,\n          })\n        })\n      }\n    }\n\n    if (field.type === 'richText' && Array.isArray(data[field.name])) {\n      // Slate richText\n      const editor: LexicalRichTextAdapter = field.editor as LexicalRichTextAdapter\n      if (editor && typeof editor === 'object') {\n        if ('features' in editor && editor.features?.length) {\n          // find slatetolexical feature\n          const slateToLexicalFeature = editor.editorConfig.resolvedFeatureMap.get('slateToLexical')\n          if (slateToLexicalFeature) {\n            // DO CONVERSION\n\n            const converterProviders = (\n              slateToLexicalFeature.sanitizedServerFeatureProps as {\n                converters?: SlateNodeConverterProvider[]\n              }\n            ).converters\n\n            const converters: SlateNodeConverter[] = []\n\n            for (const converter of converterProviders) {\n              converters.push(converter.converter)\n            }\n\n            data[field.name] = convertSlateToLexical({\n              converters,\n              slateData: data[field.name],\n            })\n\n            found++\n          }\n        }\n      }\n    }\n  }\n\n  return found\n}\n"],"names":["fieldAffectsData","fieldHasSubFields","fieldIsArrayType","convertSlateToLexical","migrateDocumentFieldsRecursively","data","fields","found","field","name","type","tabs","forEach","tab","Array","isArray","row","i","block","blocks","find","slug","blockType","_","editor","features","length","slateToLexicalFeature","editorConfig","resolvedFeatureMap","get","converterProviders","sanitizedServerFeatureProps","converters","converter","push","slateData"],"mappings":"AAEA,SAASA,gBAAgB,EAAEC,iBAAiB,EAAEC,gBAAgB,QAAQ,iBAAgB;AAQtF,SAASC,qBAAqB,QAAQ,8DAA6D;AASnG,OAAO,MAAMC,mCAAmC,CAAC,EAC/CC,IAAI,EACJC,MAAM,EACNC,KAAK,EACoB;IACzB,KAAK,MAAMC,SAASF,OAAQ;QAC1B,IAAIL,kBAAkBO,UAAU,CAACN,iBAAiBM,QAAQ;YACxD,IAAIR,iBAAiBQ,UAAU,OAAOH,IAAI,CAACG,MAAMC,IAAI,CAAC,KAAK,UAAU;gBACnEL,iCAAiC;oBAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC;oBACtBH,QAAQE,MAAMF,MAAM;oBACpBC;gBACF;YACF,OAAO;gBACLH,iCAAiC;oBAC/BC;oBACAE;oBAEAD,QAAQE,MAAMF,MAAM;gBACtB;YACF;QACF,OAAO,IAAIE,MAAME,IAAI,KAAK,QAAQ;YAChCF,MAAMG,IAAI,CAACC,OAAO,CAAC,CAACC;gBAClBT,iCAAiC;oBAC/BC;oBACAE;oBAEAD,QAAQO,IAAIP,MAAM;gBACpB;YACF;QACF,OAAO,IAAIQ,MAAMC,OAAO,CAACV,IAAI,CAACG,MAAMC,IAAI,CAAC,GAAG;YAC1C,IAAID,MAAME,IAAI,KAAK,UAAU;gBAC3BL,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACI,KAAKC;oBAC7B,MAAMC,QAAQV,MAAMW,MAAM,CAACC,IAAI,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA,SAASL,KAAKM;oBAC5D,IAAIJ,OAAO;wBACTd,iCAAiC;4BAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACQ,EAAE;4BACzBV;4BAEAD,QAAQY,MAAMZ,MAAM;wBACtB;oBACF;gBACF;YACF;YAEA,IAAIE,MAAME,IAAI,KAAK,SAAS;gBAC1BL,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACW,GAAGN;oBAC3Bb,iCAAiC;wBAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACQ,EAAE;wBACzBV;wBAEAD,QAAQE,MAAMF,MAAM;oBACtB;gBACF;YACF;QACF;QAEA,IAAIE,MAAME,IAAI,KAAK,cAAcI,MAAMC,OAAO,CAACV,IAAI,CAACG,MAAMC,IAAI,CAAC,GAAG;YAChE,iBAAiB;YACjB,MAAMe,SAAiChB,MAAMgB,MAAM;YACnD,IAAIA,UAAU,OAAOA,WAAW,UAAU;gBACxC,IAAI,cAAcA,UAAUA,OAAOC,QAAQ,EAAEC,QAAQ;oBACnD,8BAA8B;oBAC9B,MAAMC,wBAAwBH,OAAOI,YAAY,CAACC,kBAAkB,CAACC,GAAG,CAAC;oBACzE,IAAIH,uBAAuB;wBACzB,gBAAgB;wBAEhB,MAAMI,qBAAqB,AACzBJ,sBAAsBK,2BAA2B,CAGjDC,UAAU;wBAEZ,MAAMA,aAAmC,EAAE;wBAE3C,KAAK,MAAMC,aAAaH,mBAAoB;4BAC1CE,WAAWE,IAAI,CAACD,UAAUA,SAAS;wBACrC;wBAEA7B,IAAI,CAACG,MAAMC,IAAI,CAAC,GAAGN,sBAAsB;4BACvC8B;4BACAG,WAAW/B,IAAI,CAACG,MAAMC,IAAI,CAAC;wBAC7B;wBAEAF;oBACF;gBACF;YACF;QACF;IACF;IAEA,OAAOA;AACT,EAAC"}

package/dist/utilities/recurseNodeTree.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedLexicalNode } from 'lexical';
+export declare const recurseNodeTree: ({ flattenedNodes, nodeIDMap, nodes, }: {
+    flattenedNodes?: SerializedLexicalNode[];
+    nodeIDMap?: {
+        [key: string]: SerializedLexicalNode;
+    };
+    nodes: SerializedLexicalNode[];
+}) => void;
+//# sourceMappingURL=recurseNodeTree.d.ts.map

package/dist/utilities/recurseNodeTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recurseNodeTree.d.ts","sourceRoot":"","sources":["../../src/utilities/recurseNodeTree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGpD,eAAO,MAAM,eAAe,0CAIzB;IACD,cAAc,CAAC,EAAE,qBAAqB,EAAE,CAAA;IACxC,SAAS,CAAC,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAA;KACrC,CAAA;IACD,KAAK,EAAE,qBAAqB,EAAE,CAAA;CAC/B,KAAG,IA+BH,CAAA"}

package/dist/utilities/recurseNodeTree.js

@@ -0,0 +1,27 @@
+// Initialize both flattenedNodes and nodeIDMap
+export const recurseNodeTree = ({ flattenedNodes, nodeIDMap, nodes })=>{
+    if (!nodes?.length) {
+        return;
+    }
+    for (const node of nodes){
+        if (flattenedNodes) {
+            flattenedNodes.push(node);
+        }
+        if (nodeIDMap) {
+            if (node && 'id' in node && node.id) {
+                nodeIDMap[node.id] = node;
+            } else if ('fields' in node && typeof node.fields === 'object' && node.fields && 'id' in node.fields && node?.fields?.id) {
+                nodeIDMap[node.fields.id] = node;
+            }
+        }
+        if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {
+            recurseNodeTree({
+                flattenedNodes,
+                nodeIDMap,
+                nodes: node.children
+            });
+        }
+    }
+};
+
+//# sourceMappingURL=recurseNodeTree.js.map

package/dist/utilities/recurseNodeTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/recurseNodeTree.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\n// Initialize both flattenedNodes and nodeIDMap\nexport const recurseNodeTree = ({\n  flattenedNodes,\n  nodeIDMap,\n  nodes,\n}: {\n  flattenedNodes?: SerializedLexicalNode[]\n  nodeIDMap?: {\n    [key: string]: SerializedLexicalNode\n  }\n  nodes: SerializedLexicalNode[]\n}): void => {\n  if (!nodes?.length) {\n    return\n  }\n\n  for (const node of nodes) {\n    if (flattenedNodes) {\n      flattenedNodes.push(node)\n    }\n    if (nodeIDMap) {\n      if (node && 'id' in node && node.id) {\n        nodeIDMap[node.id as string] = node\n      } else if (\n        'fields' in node &&\n        typeof node.fields === 'object' &&\n        node.fields &&\n        'id' in node.fields &&\n        node?.fields?.id\n      ) {\n        nodeIDMap[node.fields.id as string] = node\n      }\n    }\n\n    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {\n      recurseNodeTree({\n        flattenedNodes,\n        nodeIDMap,\n        nodes: node.children as SerializedLexicalNode[],\n      })\n    }\n  }\n}\n"],"names":["recurseNodeTree","flattenedNodes","nodeIDMap","nodes","length","node","push","id","fields","Array","isArray","children"],"mappings":"AAEA,+CAA+C;AAC/C,OAAO,MAAMA,kBAAkB,CAAC,EAC9BC,cAAc,EACdC,SAAS,EACTC,KAAK,EAON;IACC,IAAI,CAACA,OAAOC,QAAQ;QAClB;IACF;IAEA,KAAK,MAAMC,QAAQF,MAAO;QACxB,IAAIF,gBAAgB;YAClBA,eAAeK,IAAI,CAACD;QACtB;QACA,IAAIH,WAAW;YACb,IAAIG,QAAQ,QAAQA,QAAQA,KAAKE,EAAE,EAAE;gBACnCL,SAAS,CAACG,KAAKE,EAAE,CAAW,GAAGF;YACjC,OAAO,IACL,YAAYA,QACZ,OAAOA,KAAKG,MAAM,KAAK,YACvBH,KAAKG,MAAM,IACX,QAAQH,KAAKG,MAAM,IACnBH,MAAMG,QAAQD,IACd;gBACAL,SAAS,CAACG,KAAKG,MAAM,CAACD,EAAE,CAAW,GAAGF;YACxC;QACF;QAEA,IAAI,cAAcA,QAAQI,MAAMC,OAAO,CAACL,MAAMM,aAAaN,MAAMM,UAAUP,QAAQ;YACjFJ,gBAAgB;gBACdC;gBACAC;gBACAC,OAAOE,KAAKM,QAAQ;YACtB;QACF;IACF;AACF,EAAC"}

package/dist/utilities/upgradeLexicalData/index.d.ts

@@ -0,0 +1,11 @@
+import type { Payload } from 'payload';
+/**
+ * This goes through every single document in your payload app and re-saves it, if it has a lexical editor.
+ * This way, the data is automatically converted to the new format, and that automatic conversion gets applied to every single document in your app.
+ *
+ * @param payload
+ */
+export declare function upgradeLexicalData({ payload }: {
+    payload: Payload;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/utilities/upgradeLexicalData/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utilities/upgradeLexicalData/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyC,OAAO,EAAE,MAAM,SAAS,CAAA;AAI7E;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,iBA0BzE"}

package/dist/utilities/upgradeLexicalData/index.js

@@ -0,0 +1,101 @@
+import { upgradeDocumentFieldsRecursively } from './upgradeDocumentFieldsRecursively.js';
+/**
+ * This goes through every single document in your payload app and re-saves it, if it has a lexical editor.
+ * This way, the data is automatically converted to the new format, and that automatic conversion gets applied to every single document in your app.
+ *
+ * @param payload
+ */ export async function upgradeLexicalData({ payload }) {
+    const collections = payload.config.collections;
+    const allLocales = payload.config.localization ? payload.config.localization.localeCodes : [
+        null
+    ];
+    const totalCollections = collections.length;
+    for (const locale of allLocales){
+        let curCollection = 0;
+        for (const collection of collections){
+            curCollection++;
+            await upgradeCollection({
+                collection,
+                cur: curCollection,
+                locale,
+                max: totalCollections,
+                payload
+            });
+        }
+        for (const global of payload.config.globals){
+            await upgradeGlobal({
+                global,
+                locale,
+                payload
+            });
+        }
+    }
+}
+async function upgradeGlobal({ global, locale, payload }) {
+    console.log(`Lexical Upgrader: ${locale}: Upgrading global:`, global.slug);
+    const document = await payload.findGlobal({
+        slug: global.slug,
+        depth: 0,
+        locale: locale || undefined,
+        overrideAccess: true
+    });
+    const found = upgradeDocument({
+        document,
+        fields: global.fields
+    });
+    if (found) {
+        await payload.updateGlobal({
+            slug: global.slug,
+            data: document,
+            depth: 0,
+            locale: locale || undefined
+        });
+    }
+}
+async function upgradeCollection({ collection, cur, locale, max, payload }) {
+    console.log(`Lexical Upgrade: ${locale}: Upgrading collection:`, collection.slug, '(' + cur + '/' + max + ')');
+    const documentCount = (await payload.count({
+        collection: collection.slug,
+        depth: 0,
+        locale: locale || undefined
+    })).totalDocs;
+    let page = 1;
+    let upgraded = 0;
+    while(upgraded < documentCount){
+        const documents = await payload.find({
+            collection: collection.slug,
+            depth: 0,
+            locale: locale || undefined,
+            overrideAccess: true,
+            page,
+            pagination: true
+        });
+        for (const document of documents.docs){
+            upgraded++;
+            console.log(`Lexical Upgrade: ${locale}: Upgrading collection:`, collection.slug, '(' + cur + '/' + max + ') - Upgrading Document: ' + document.id + ' (' + upgraded + '/' + documentCount + ')');
+            const found = upgradeDocument({
+                document,
+                fields: collection.fields
+            });
+            if (found) {
+                await payload.update({
+                    id: document.id,
+                    collection: collection.slug,
+                    data: document,
+                    depth: 0,
+                    locale: locale || undefined
+                });
+            }
+        }
+        page++;
+    }
+}
+function upgradeDocument({ document, fields }) {
+    return !!upgradeDocumentFieldsRecursively({
+        data: document,
+        fields,
+        found: 0
+    });
+}
+
+//# sourceMappingURL=index.js.map

package/dist/utilities/upgradeLexicalData/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/upgradeLexicalData/index.ts"],"sourcesContent":["import type { CollectionConfig, Field, GlobalConfig, Payload } from 'payload'\n\nimport { upgradeDocumentFieldsRecursively } from './upgradeDocumentFieldsRecursively.js'\n\n/**\n * This goes through every single document in your payload app and re-saves it, if it has a lexical editor.\n * This way, the data is automatically converted to the new format, and that automatic conversion gets applied to every single document in your app.\n *\n * @param payload\n */\nexport async function upgradeLexicalData({ payload }: { payload: Payload }) {\n  const collections = payload.config.collections\n\n  const allLocales = payload.config.localization ? payload.config.localization.localeCodes : [null]\n\n  const totalCollections = collections.length\n  for (const locale of allLocales) {\n    let curCollection = 0\n    for (const collection of collections) {\n      curCollection++\n      await upgradeCollection({\n        collection,\n        cur: curCollection,\n        locale,\n        max: totalCollections,\n        payload,\n      })\n    }\n    for (const global of payload.config.globals) {\n      await upgradeGlobal({\n        global,\n        locale,\n        payload,\n      })\n    }\n  }\n}\n\nasync function upgradeGlobal({\n  global,\n  locale,\n  payload,\n}: {\n  global: GlobalConfig\n  locale: null | string\n  payload: Payload\n}) {\n  console.log(`Lexical Upgrader: ${locale}: Upgrading global:`, global.slug)\n\n  const document = await payload.findGlobal({\n    slug: global.slug,\n    depth: 0,\n    locale: locale || undefined,\n    overrideAccess: true,\n  })\n\n  const found = upgradeDocument({\n    document,\n    fields: global.fields,\n  })\n\n  if (found) {\n    await payload.updateGlobal({\n      slug: global.slug,\n      data: document,\n      depth: 0,\n      locale: locale || undefined,\n    })\n  }\n}\n\nasync function upgradeCollection({\n  collection,\n  cur,\n  locale,\n  max,\n  payload,\n}: {\n  collection: CollectionConfig\n  cur: number\n  locale: null | string\n  max: number\n  payload: Payload\n}) {\n  console.log(\n    `Lexical Upgrade: ${locale}: Upgrading collection:`,\n    collection.slug,\n    '(' + cur + '/' + max + ')',\n  )\n\n  const documentCount = (\n    await payload.count({\n      collection: collection.slug,\n      depth: 0,\n      locale: locale || undefined,\n    })\n  ).totalDocs\n\n  let page = 1\n  let upgraded = 0\n\n  while (upgraded < documentCount) {\n    const documents = await payload.find({\n      collection: collection.slug,\n      depth: 0,\n      locale: locale || undefined,\n      overrideAccess: true,\n      page,\n      pagination: true,\n    })\n\n    for (const document of documents.docs) {\n      upgraded++\n      console.log(\n        `Lexical Upgrade: ${locale}: Upgrading collection:`,\n        collection.slug,\n        '(' +\n          cur +\n          '/' +\n          max +\n          ') - Upgrading Document: ' +\n          document.id +\n          ' (' +\n          upgraded +\n          '/' +\n          documentCount +\n          ')',\n      )\n      const found = upgradeDocument({\n        document,\n        fields: collection.fields,\n      })\n\n      if (found) {\n        await payload.update({\n          id: document.id,\n          collection: collection.slug,\n          data: document,\n          depth: 0,\n          locale: locale || undefined,\n        })\n      }\n    }\n    page++\n  }\n}\n\nfunction upgradeDocument({\n  document,\n  fields,\n}: {\n  document: Record<string, unknown>\n  fields: Field[]\n}): boolean {\n  return !!upgradeDocumentFieldsRecursively({\n    data: document,\n    fields,\n    found: 0,\n  })\n}\n"],"names":["upgradeDocumentFieldsRecursively","upgradeLexicalData","payload","collections","config","allLocales","localization","localeCodes","totalCollections","length","locale","curCollection","collection","upgradeCollection","cur","max","global","globals","upgradeGlobal","console","log","slug","document","findGlobal","depth","undefined","overrideAccess","found","upgradeDocument","fields","updateGlobal","data","documentCount","count","totalDocs","page","upgraded","documents","find","pagination","docs","id","update"],"mappings":"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"}

package/dist/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.d.ts

@@ -0,0 +1,9 @@
+import type { Field } from 'payload';
+type NestedRichTextFieldsArgs = {
+    data: unknown;
+    fields: Field[];
+    found: number;
+};
+export declare const upgradeDocumentFieldsRecursively: ({ data, fields, found, }: NestedRichTextFieldsArgs) => number;
+export {};
+//# sourceMappingURL=upgradeDocumentFieldsRecursively.d.ts.map

package/dist/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeDocumentFieldsRecursively.d.ts","sourceRoot":"","sources":["../../../src/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AASpC,KAAK,wBAAwB,GAAG;IAC9B,IAAI,EAAE,OAAO,CAAA;IAEb,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,gCAAgC,6BAI1C,wBAAwB,KAAG,MAmF7B,CAAA"}

package/dist/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.js

@@ -0,0 +1,74 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { fieldAffectsData, fieldHasSubFields, fieldIsArrayType } from 'payload/shared';
+import { getEnabledNodes } from '../../lexical/nodes/index.js';
+export const upgradeDocumentFieldsRecursively = ({ data, fields, found })=>{
+    for (const field of fields){
+        if (fieldHasSubFields(field) && !fieldIsArrayType(field)) {
+            if (fieldAffectsData(field) && typeof data[field.name] === 'object') {
+                upgradeDocumentFieldsRecursively({
+                    data: data[field.name],
+                    fields: field.fields,
+                    found
+                });
+            } else {
+                upgradeDocumentFieldsRecursively({
+                    data,
+                    found,
+                    fields: field.fields
+                });
+            }
+        } else if (field.type === 'tabs') {
+            field.tabs.forEach((tab)=>{
+                upgradeDocumentFieldsRecursively({
+                    data,
+                    found,
+                    fields: tab.fields
+                });
+            });
+        } 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) {
+                        upgradeDocumentFieldsRecursively({
+                            data: data[field.name][i],
+                            found,
+                            fields: block.fields
+                        });
+                    }
+                });
+            }
+            if (field.type === 'array') {
+                data[field.name].forEach((_, i)=>{
+                    upgradeDocumentFieldsRecursively({
+                        data: data[field.name][i],
+                        found,
+                        fields: field.fields
+                    });
+                });
+            }
+        }
+        if (field.type === 'richText' && data[field.name] && !Array.isArray(data[field.name]) && 'root' in data[field.name]) {
+            // Lexical richText
+            const editor = field.editor;
+            if (editor && typeof editor === 'object') {
+                if ('features' in editor && editor.features?.length) {
+                    // Load lexical editor into lexical, then save it immediately
+                    const editorState = data[field.name];
+                    const headlessEditor = createHeadlessEditor({
+                        nodes: getEnabledNodes({
+                            editorConfig: editor.editorConfig
+                        })
+                    });
+                    headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState));
+                    // get editor state
+                    data[field.name] = headlessEditor.getEditorState().toJSON();
+                    found++;
+                }
+            }
+        }
+    }
+    return found;
+};
+
+//# sourceMappingURL=upgradeDocumentFieldsRecursively.js.map

package/dist/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/upgradeLexicalData/upgradeDocumentFieldsRecursively.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field } from 'payload'\n\nimport { createHeadlessEditor } from '@lexical/headless'\nimport { fieldAffectsData, fieldHasSubFields, fieldIsArrayType } from 'payload/shared'\n\nimport type { LexicalRichTextAdapter } from '../../types.js'\n\nimport { getEnabledNodes } from '../../lexical/nodes/index.js'\n\ntype NestedRichTextFieldsArgs = {\n  data: unknown\n\n  fields: Field[]\n  found: number\n}\n\nexport const upgradeDocumentFieldsRecursively = ({\n  data,\n  fields,\n  found,\n}: NestedRichTextFieldsArgs): number => {\n  for (const field of fields) {\n    if (fieldHasSubFields(field) && !fieldIsArrayType(field)) {\n      if (fieldAffectsData(field) && typeof data[field.name] === 'object') {\n        upgradeDocumentFieldsRecursively({\n          data: data[field.name],\n          fields: field.fields,\n          found,\n        })\n      } else {\n        upgradeDocumentFieldsRecursively({\n          data,\n          found,\n\n          fields: field.fields,\n        })\n      }\n    } else if (field.type === 'tabs') {\n      field.tabs.forEach((tab) => {\n        upgradeDocumentFieldsRecursively({\n          data,\n          found,\n\n          fields: tab.fields,\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            upgradeDocumentFieldsRecursively({\n              data: data[field.name][i],\n              found,\n\n              fields: block.fields,\n            })\n          }\n        })\n      }\n\n      if (field.type === 'array') {\n        data[field.name].forEach((_, i) => {\n          upgradeDocumentFieldsRecursively({\n            data: data[field.name][i],\n            found,\n\n            fields: field.fields,\n          })\n        })\n      }\n    }\n\n    if (\n      field.type === 'richText' &&\n      data[field.name] &&\n      !Array.isArray(data[field.name]) &&\n      'root' in data[field.name]\n    ) {\n      // Lexical richText\n      const editor: LexicalRichTextAdapter = field.editor as LexicalRichTextAdapter\n      if (editor && typeof editor === 'object') {\n        if ('features' in editor && editor.features?.length) {\n          // Load lexical editor into lexical, then save it immediately\n          const editorState: SerializedEditorState = data[field.name]\n\n          const headlessEditor = createHeadlessEditor({\n            nodes: getEnabledNodes({\n              editorConfig: editor.editorConfig,\n            }),\n          })\n          headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState))\n\n          // get editor state\n          data[field.name] = headlessEditor.getEditorState().toJSON()\n\n          found++\n        }\n      }\n    }\n  }\n\n  return found\n}\n"],"names":["createHeadlessEditor","fieldAffectsData","fieldHasSubFields","fieldIsArrayType","getEnabledNodes","upgradeDocumentFieldsRecursively","data","fields","found","field","name","type","tabs","forEach","tab","Array","isArray","row","i","block","blocks","find","slug","blockType","_","editor","features","length","editorState","headlessEditor","nodes","editorConfig","setEditorState","parseEditorState","getEditorState","toJSON"],"mappings":"AAGA,SAASA,oBAAoB,QAAQ,oBAAmB;AACxD,SAASC,gBAAgB,EAAEC,iBAAiB,EAAEC,gBAAgB,QAAQ,iBAAgB;AAItF,SAASC,eAAe,QAAQ,+BAA8B;AAS9D,OAAO,MAAMC,mCAAmC,CAAC,EAC/CC,IAAI,EACJC,MAAM,EACNC,KAAK,EACoB;IACzB,KAAK,MAAMC,SAASF,OAAQ;QAC1B,IAAIL,kBAAkBO,UAAU,CAACN,iBAAiBM,QAAQ;YACxD,IAAIR,iBAAiBQ,UAAU,OAAOH,IAAI,CAACG,MAAMC,IAAI,CAAC,KAAK,UAAU;gBACnEL,iCAAiC;oBAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC;oBACtBH,QAAQE,MAAMF,MAAM;oBACpBC;gBACF;YACF,OAAO;gBACLH,iCAAiC;oBAC/BC;oBACAE;oBAEAD,QAAQE,MAAMF,MAAM;gBACtB;YACF;QACF,OAAO,IAAIE,MAAME,IAAI,KAAK,QAAQ;YAChCF,MAAMG,IAAI,CAACC,OAAO,CAAC,CAACC;gBAClBT,iCAAiC;oBAC/BC;oBACAE;oBAEAD,QAAQO,IAAIP,MAAM;gBACpB;YACF;QACF,OAAO,IAAIQ,MAAMC,OAAO,CAACV,IAAI,CAACG,MAAMC,IAAI,CAAC,GAAG;YAC1C,IAAID,MAAME,IAAI,KAAK,UAAU;gBAC3BL,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACI,KAAKC;oBAC7B,MAAMC,QAAQV,MAAMW,MAAM,CAACC,IAAI,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA,SAASL,KAAKM;oBAC5D,IAAIJ,OAAO;wBACTd,iCAAiC;4BAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACQ,EAAE;4BACzBV;4BAEAD,QAAQY,MAAMZ,MAAM;wBACtB;oBACF;gBACF;YACF;YAEA,IAAIE,MAAME,IAAI,KAAK,SAAS;gBAC1BL,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACW,GAAGN;oBAC3Bb,iCAAiC;wBAC/BC,MAAMA,IAAI,CAACG,MAAMC,IAAI,CAAC,CAACQ,EAAE;wBACzBV;wBAEAD,QAAQE,MAAMF,MAAM;oBACtB;gBACF;YACF;QACF;QAEA,IACEE,MAAME,IAAI,KAAK,cACfL,IAAI,CAACG,MAAMC,IAAI,CAAC,IAChB,CAACK,MAAMC,OAAO,CAACV,IAAI,CAACG,MAAMC,IAAI,CAAC,KAC/B,UAAUJ,IAAI,CAACG,MAAMC,IAAI,CAAC,EAC1B;YACA,mBAAmB;YACnB,MAAMe,SAAiChB,MAAMgB,MAAM;YACnD,IAAIA,UAAU,OAAOA,WAAW,UAAU;gBACxC,IAAI,cAAcA,UAAUA,OAAOC,QAAQ,EAAEC,QAAQ;oBACnD,6DAA6D;oBAC7D,MAAMC,cAAqCtB,IAAI,CAACG,MAAMC,IAAI,CAAC;oBAE3D,MAAMmB,iBAAiB7B,qBAAqB;wBAC1C8B,OAAO1B,gBAAgB;4BACrB2B,cAAcN,OAAOM,YAAY;wBACnC;oBACF;oBACAF,eAAeG,cAAc,CAACH,eAAeI,gBAAgB,CAACL;oBAE9D,mBAAmB;oBACnBtB,IAAI,CAACG,MAAMC,IAAI,CAAC,GAAGmB,eAAeK,cAAc,GAAGC,MAAM;oBAEzD3B;gBACF;YACF;QACF;IACF;IAEA,OAAOA;AACT,EAAC"}

package/dist/utilities/useLexicalFeature.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProviderClient } from '../features/typesClient.js';
+export declare const useLexicalFeature: <ClientFeatureProps>(featureKey: string, feature: FeatureProviderClient<ClientFeatureProps>) => void;
+//# sourceMappingURL=useLexicalFeature.d.ts.map

package/dist/utilities/useLexicalFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalFeature.d.ts","sourceRoot":"","sources":["../../src/utilities/useLexicalFeature.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAEvE,eAAO,MAAM,iBAAiB,GAAI,kBAAkB,cACtC,MAAM,WACT,qBAAqB,CAAC,kBAAkB,CAAC,SAUnD,CAAA"}

package/dist/utilities/useLexicalFeature.js

@@ -0,0 +1,12 @@
+'use client';
+import { useAddClientFunction, useFieldProps, useTableCell } from '@payloadcms/ui';
+export const useLexicalFeature = (featureKey, feature)=>{
+    const { schemaPath: schemaPathFromFieldProps } = useFieldProps();
+    const tableCell = useTableCell();
+    const schemaPathFromCellProps = tableCell?.cellProps?.schemaPath;
+    const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.
+    ;
+    useAddClientFunction(`lexicalFeature.${schemaPath}.${featureKey}`, feature);
+};
+
+//# sourceMappingURL=useLexicalFeature.js.map

package/dist/utilities/useLexicalFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/useLexicalFeature.tsx"],"sourcesContent":["'use client'\n\nimport { useAddClientFunction, useFieldProps, useTableCell } from '@payloadcms/ui'\n\nimport type { FeatureProviderClient } from '../features/typesClient.js'\n\nexport const useLexicalFeature = <ClientFeatureProps,>(\n  featureKey: string,\n  feature: FeatureProviderClient<ClientFeatureProps>,\n) => {\n  const { schemaPath: schemaPathFromFieldProps } = useFieldProps()\n  const tableCell = useTableCell()\n\n  const schemaPathFromCellProps = tableCell?.cellProps?.schemaPath\n\n  const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.\n\n  useAddClientFunction(`lexicalFeature.${schemaPath}.${featureKey}`, feature)\n}\n"],"names":["useAddClientFunction","useFieldProps","useTableCell","useLexicalFeature","featureKey","feature","schemaPath","schemaPathFromFieldProps","tableCell","schemaPathFromCellProps","cellProps"],"mappings":"AAAA;AAEA,SAASA,oBAAoB,EAAEC,aAAa,EAAEC,YAAY,QAAQ,iBAAgB;AAIlF,OAAO,MAAMC,oBAAoB,CAC/BC,YACAC;IAEA,MAAM,EAAEC,YAAYC,wBAAwB,EAAE,GAAGN;IACjD,MAAMO,YAAYN;IAElB,MAAMO,0BAA0BD,WAAWE,WAAWJ;IAEtD,MAAMA,aAAaG,2BAA2BF,yBAAyB,iOAAiO;;IAExSP,qBAAqB,CAAC,eAAe,EAAEM,WAAW,CAAC,EAAEF,WAAW,CAAC,EAAEC;AACrE,EAAC"}

package/dist/validate/index.d.ts

@@ -1,7 +1,7 @@
 import type { SerializedEditorState } from 'lexical';
-import type { RichTextField, Validate } from 'payload/types';
-import type { SanitizedServerEditorConfig } from '../field/lexical/config/types.js';
+import type { RichTextField, Validate } from 'payload';
+import type { SanitizedServerEditorConfig } from '../lexical/config/types.js';
 export declare const richTextValidateHOC: ({ editorConfig, }: {
     editorConfig: SanitizedServerEditorConfig;
-}) => Validate<SerializedEditorState<import("lexical/LexicalNode.js").SerializedLexicalNode>, unknown, unknown, RichTextField>;
+}) => Validate<SerializedEditorState<import("lexical").SerializedLexicalNode>, unknown, unknown, RichTextField>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validate/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAKnF,eAAO,MAAM,mBAAmB,sBAE7B;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,6HAyCA,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validate/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAA2B,MAAM,SAAS,CAAA;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEtD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAI7E,eAAO,MAAM,mBAAmB,sBAE7B;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,8GA6CA,CAAA"}

package/dist/validate/index.js

@@ -1,10 +1,11 @@
-import { defaultRichTextValue, defaultRichTextValueV2 } from '../populate/defaultValue.js';
 import { validateNodes } from './validateNodes.js';
 export const richTextValidateHOC = ({ editorConfig })=>{
     const richTextValidate = async (value, options)=>{
         const { req: { t }, required } = options;
         if (required) {
-            if (!value || !value?.root?.children || !value?.root?.children?.length || JSON.stringify(value) === JSON.stringify(defaultRichTextValue) || JSON.stringify(value) === JSON.stringify(defaultRichTextValueV2)) {
+            const hasChildren = value?.root?.children?.length;
+            const hasOnlyEmptyParagraph = value?.root?.children?.length === 1 && value?.root?.children[0]?.type === 'paragraph' && value?.root?.children[0]?.children?.length === 0 || value?.root?.children[0]?.children?.length === 1 && value?.root?.children[0]?.children[0]?.type === 'text' && value?.root?.children[0]?.children[0]?.['text'] === '';
+            if (!hasChildren || hasOnlyEmptyParagraph) {
                 return t('validation:required');
             }
         }

package/dist/validate/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validate/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextField, Validate } from 'payload/types'\n\nimport type { SanitizedServerEditorConfig } from '../field/lexical/config/types.js'\n\nimport { defaultRichTextValue, defaultRichTextValueV2 } from '../populate/defaultValue.js'\nimport { validateNodes } from './validateNodes.js'\n\nexport const richTextValidateHOC = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}) => {\n  const richTextValidate: Validate<SerializedEditorState, unknown, unknown, RichTextField> = async (\n    value,\n    options,\n  ) => {\n    const {\n      req: { t },\n      required,\n    } = options\n\n    if (required) {\n      if (\n        !value ||\n        !value?.root?.children ||\n        !value?.root?.children?.length ||\n        JSON.stringify(value) === JSON.stringify(defaultRichTextValue) ||\n        JSON.stringify(value) === JSON.stringify(defaultRichTextValueV2)\n      ) {\n        return t('validation:required')\n      }\n    }\n\n    // Traverse through nodes and validate them. Just like a node can hook into the population process (e.g. link or relationship nodes),\n    // they can also hook into the validation process. E.g. a block node probably has fields with validation rules.\n\n    const rootNodes = value?.root?.children\n    if (rootNodes && Array.isArray(rootNodes) && rootNodes?.length) {\n      return await validateNodes({\n        nodeValidations: editorConfig.features.validations,\n        nodes: rootNodes,\n        validation: {\n          options,\n          value,\n        },\n      })\n    }\n\n    return true\n  }\n\n  return richTextValidate\n}\n"],"names":["defaultRichTextValue","defaultRichTextValueV2","validateNodes","richTextValidateHOC","editorConfig","richTextValidate","value","options","req","t","required","root","children","length","JSON","stringify","rootNodes","Array","isArray","nodeValidations","features","validations","nodes","validation"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,oBAAoB,EAAEC,sBAAsB,QAAQ,8BAA6B;AAC1F,SAASC,aAAa,QAAQ,qBAAoB;AAElD,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,YAAY,EAGb;IACC,MAAMC,mBAAqF,OACzFC,OACAC;QAEA,MAAM,EACJC,KAAK,EAAEC,CAAC,EAAE,EACVC,QAAQ,EACT,GAAGH;QAEJ,IAAIG,UAAU;YACZ,IACE,CAACJ,SACD,CAACA,OAAOK,MAAMC,YACd,CAACN,OAAOK,MAAMC,UAAUC,UACxBC,KAAKC,SAAS,CAACT,WAAWQ,KAAKC,SAAS,CAACf,yBACzCc,KAAKC,SAAS,CAACT,WAAWQ,KAAKC,SAAS,CAACd,yBACzC;gBACA,OAAOQ,EAAE;YACX;QACF;QAEA,qIAAqI;QACrI,+GAA+G;QAE/G,MAAMO,YAAYV,OAAOK,MAAMC;QAC/B,IAAII,aAAaC,MAAMC,OAAO,CAACF,cAAcA,WAAWH,QAAQ;YAC9D,OAAO,MAAMX,cAAc;gBACzBiB,iBAAiBf,aAAagB,QAAQ,CAACC,WAAW;gBAClDC,OAAON;gBACPO,YAAY;oBACVhB;oBACAD;gBACF;YACF;QACF;QAEA,OAAO;IACT;IAEA,OAAOD;AACT,EAAC"}
+{"version":3,"sources":["../../src/validate/index.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedParagraphNode } from 'lexical'\nimport type { RichTextField, Validate } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\n\nimport { validateNodes } from './validateNodes.js'\n\nexport const richTextValidateHOC = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}) => {\n  const richTextValidate: Validate<SerializedEditorState, unknown, unknown, RichTextField> = async (\n    value,\n    options,\n  ) => {\n    const {\n      req: { t },\n      required,\n    } = options\n\n    if (required) {\n      const hasChildren = value?.root?.children?.length\n\n      const hasOnlyEmptyParagraph =\n        (value?.root?.children?.length === 1 &&\n          value?.root?.children[0]?.type === 'paragraph' &&\n          (value?.root?.children[0] as SerializedParagraphNode)?.children?.length === 0) ||\n        ((value?.root?.children[0] as SerializedParagraphNode)?.children?.length === 1 &&\n          (value?.root?.children[0] as SerializedParagraphNode)?.children[0]?.type === 'text' &&\n          (value?.root?.children[0] as SerializedParagraphNode)?.children[0]?.['text'] === '')\n\n      if (!hasChildren || hasOnlyEmptyParagraph) {\n        return t('validation:required')\n      }\n    }\n\n    // Traverse through nodes and validate them. Just like a node can hook into the population process (e.g. link or relationship nodes),\n    // they can also hook into the validation process. E.g. a block node probably has fields with validation rules.\n\n    const rootNodes = value?.root?.children\n    if (rootNodes && Array.isArray(rootNodes) && rootNodes?.length) {\n      return await validateNodes({\n        nodeValidations: editorConfig.features.validations,\n        nodes: rootNodes,\n        validation: {\n          options,\n          value,\n        },\n      })\n    }\n\n    return true\n  }\n\n  return richTextValidate\n}\n"],"names":["validateNodes","richTextValidateHOC","editorConfig","richTextValidate","value","options","req","t","required","hasChildren","root","children","length","hasOnlyEmptyParagraph","type","rootNodes","Array","isArray","nodeValidations","features","validations","nodes","validation"],"mappings":"AAKA,SAASA,aAAa,QAAQ,qBAAoB;AAElD,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,YAAY,EAGb;IACC,MAAMC,mBAAqF,OACzFC,OACAC;QAEA,MAAM,EACJC,KAAK,EAAEC,CAAC,EAAE,EACVC,QAAQ,EACT,GAAGH;QAEJ,IAAIG,UAAU;YACZ,MAAMC,cAAcL,OAAOM,MAAMC,UAAUC;YAE3C,MAAMC,wBACJ,AAACT,OAAOM,MAAMC,UAAUC,WAAW,KACjCR,OAAOM,MAAMC,QAAQ,CAAC,EAAE,EAAEG,SAAS,eACnC,AAACV,OAAOM,MAAMC,QAAQ,CAAC,EAAE,EAA8BA,UAAUC,WAAW,KAC7E,AAACR,OAAOM,MAAMC,QAAQ,CAAC,EAAE,EAA8BA,UAAUC,WAAW,KAC3E,AAACR,OAAOM,MAAMC,QAAQ,CAAC,EAAE,EAA8BA,QAAQ,CAAC,EAAE,EAAEG,SAAS,UAC7E,AAACV,OAAOM,MAAMC,QAAQ,CAAC,EAAE,EAA8BA,QAAQ,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK;YAErF,IAAI,CAACF,eAAeI,uBAAuB;gBACzC,OAAON,EAAE;YACX;QACF;QAEA,qIAAqI;QACrI,+GAA+G;QAE/G,MAAMQ,YAAYX,OAAOM,MAAMC;QAC/B,IAAII,aAAaC,MAAMC,OAAO,CAACF,cAAcA,WAAWH,QAAQ;YAC9D,OAAO,MAAMZ,cAAc;gBACzBkB,iBAAiBhB,aAAaiB,QAAQ,CAACC,WAAW;gBAClDC,OAAON;gBACPO,YAAY;oBACVjB;oBACAD;gBACF;YACF;QACF;QAEA,OAAO;IACT;IAEA,OAAOD;AACT,EAAC"}

package/dist/validate/validateNodes.d.ts

@@ -1,6 +1,6 @@
 import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { RichTextField, ValidateOptions } from 'payload/types';
-import type { NodeValidation } from '../field/features/types.js';
+import type { RichTextField, ValidateOptions } from 'payload';
+import type { NodeValidation } from '../features/typesServer.js';
 export declare function validateNodes({ nodeValidations, nodes, validation: validationFromProps, }: {
     nodeValidations: Map<string, Array<NodeValidation>>;
     nodes: SerializedLexicalNode[];

package/dist/validate/validateNodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateNodes.d.ts","sourceRoot":"","sources":["../../src/validate/validateNodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAEhE,wBAAsB,aAAa,CAAC,EAClC,eAAe,EACf,KAAK,EACL,UAAU,EAAE,mBAAmB,GAChC,EAAE;IACD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,UAAU,EAAE;QACV,OAAO,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAA;QACzD,KAAK,EAAE,qBAAqB,CAAA;KAC7B,CAAA;CACF,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmCzB"}
+{"version":3,"file":"validateNodes.d.ts","sourceRoot":"","sources":["../../src/validate/validateNodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAEhE,wBAAsB,aAAa,CAAC,EAClC,eAAe,EACf,KAAK,EACL,UAAU,EAAE,mBAAmB,GAChC,EAAE;IACD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,UAAU,EAAE;QACV,OAAO,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAA;QACzD,KAAK,EAAE,qBAAqB,CAAA;KAC7B,CAAA;CACF,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmCzB"}

package/dist/validate/validateNodes.js

@@ -10,7 +10,7 @@ export async function validateNodes({ nodeValidations, nodes, validation: valida
                     validation: validationFromProps
                 });
                 if (validationResult !== true) {
-                    return validationResult;
+                    return `${node.type} node failed to validate: ${validationResult}`;
                 }
             }
         }