@payloadcms/richtext-lexical 3.0.0-canary.95fcd13 → 3.0.0-canary.9beaa28

package/dist/utilities/generateComponentMap.js

@@ -1,77 +1,99 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createElement as _createElement } from "react";
-import { mapFields } from '@payloadcms/ui/utilities/buildComponentMap';
-import React from 'react';
-export const getGenerateComponentMap = (args)=>({ WithServerSideProps, config, i18n, schemaPath })=>{
-        const componentMap = new Map();
-        // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
-        const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort((a, b)=>a[1].order - b[1].order);
-        componentMap.set(`features`, resolvedFeatureMapArray.map(([featureKey, resolvedFeature])=>{
-            const ClientComponent = resolvedFeature.ClientFeature;
-            const clientComponentProps = resolvedFeature.clientFeatureProps;
-            /**
-           * Handle Feature Component Maps
-           */ if ('generateComponentMap' in resolvedFeature && typeof resolvedFeature.generateComponentMap === 'function') {
-                const components = resolvedFeature.generateComponentMap({
-                    config,
-                    i18n,
-                    props: resolvedFeature.sanitizedServerFeatureProps,
-                    schemaPath
-                });
-                for(const componentKey in components){
-                    const Component = components[componentKey];
-                    if (Component) {
-                        componentMap.set(`lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`, /*#__PURE__*/ _jsx(WithServerSideProps, {
-                            Component: Component,
-                            componentKey: componentKey,
-                            featureKey: resolvedFeature.key
-                        }, `${resolvedFeature.key}-${componentKey}`));
-                    }
-                }
-            }
-            /**
-           * Handle Feature Schema Maps (rendered fields)
-           */ if ('generateSchemaMap' in resolvedFeature && typeof resolvedFeature.generateSchemaMap === 'function') {
-                const schemas = resolvedFeature.generateSchemaMap({
-                    config,
-                    i18n,
-                    props: resolvedFeature.sanitizedServerFeatureProps,
-                    schemaMap: new Map(),
-                    schemaPath
-                });
-                if (schemas) {
-                    for (const [schemaKey, fields] of schemas.entries()){
-                        const mappedFields = mapFields({
-                            WithServerSideProps,
-                            config,
-                            disableAddingID: true,
-                            fieldSchema: fields,
-                            i18n,
-                            parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,
-                            readOnly: false
-                        });
-                        componentMap.set(`lexical_internal_feature.${featureKey}.fields.${schemaKey}`, mappedFields);
-                    }
-                }
-            }
-            if (!ClientComponent) {
-                return null;
-            }
-            return {
-                ClientFeature: clientComponentProps && typeof clientComponentProps === 'object' ? /*#__PURE__*/ _createElement(ClientComponent, {
-                    ...clientComponentProps,
-                    featureKey: resolvedFeature.key,
-                    key: resolvedFeature.key,
-                    order: resolvedFeature.order
-                }) : /*#__PURE__*/ _jsx(ClientComponent, {
-                    featureKey: resolvedFeature.key,
-                    order: resolvedFeature.order
-                }, resolvedFeature.key),
-                key: resolvedFeature.key,
-                order: resolvedFeature.order
-            };
-        }).filter((feature)=>feature !== null));
-        return componentMap;
+import { getComponent } from '@payloadcms/ui/shared';
+import { createClientFields } from '@payloadcms/ui/utilities/createClientConfig';
+import { deepCopyObjectSimple } from 'payload';
+export const getGenerateComponentMap = args => ({
+  createMappedComponent,
+  field,
+  i18n,
+  importMap,
+  payload,
+  schemaPath
+}) => {
+  const componentMap = new Map();
+  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
+  const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort((a, b) => a[1].order - b[1].order);
+  componentMap.set(`features`, resolvedFeatureMapArray.map(([featureKey, resolvedFeature]) => {
+    /**
+    * Handle Feature Component Maps
+    */
+    if ('componentMap' in resolvedFeature) {
+      const components = typeof resolvedFeature.componentMap === 'function' ? resolvedFeature.componentMap({
+        i18n,
+        payload,
+        props: resolvedFeature.sanitizedServerFeatureProps,
+        schemaPath
+      }) : resolvedFeature.componentMap;
+      for (const componentKey in components) {
+        const payloadComponent = components[componentKey];
+        const mappedComponent = createMappedComponent(payloadComponent, {
+          clientProps: {
+            componentKey,
+            featureKey: resolvedFeature.key,
+            key: `${resolvedFeature.key}-${componentKey}`
+          }
+        }, undefined, 'lexical-from-resolvedFeature');
+        if (mappedComponent) {
+          componentMap.set(`lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`, mappedComponent);
+        }
+      }
+    }
+    /**
+    * Handle Feature Schema Maps (rendered fields)
+    */
+    if ('generateSchemaMap' in resolvedFeature && typeof resolvedFeature.generateSchemaMap === 'function') {
+      const schemas = resolvedFeature.generateSchemaMap({
+        config: payload.config,
+        field,
+        i18n,
+        props: resolvedFeature.sanitizedServerFeatureProps,
+        schemaMap: new Map(),
+        schemaPath
+      });
+      if (schemas) {
+        for (const [schemaKey, fields] of schemas.entries()) {
+          let clientFields = deepCopyObjectSimple(fields);
+          clientFields = createClientFields({
+            clientFields,
+            createMappedComponent,
+            disableAddingID: true,
+            fields,
+            i18n,
+            importMap,
+            parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,
+            payload
+          });
+          componentMap.set(`lexical_internal_feature.${featureKey}.fields.${schemaKey}`, clientFields);
+        }
+      }
+    }
+    const ClientComponent = resolvedFeature.ClientFeature;
+    const ResolvedClientComponent = getComponent({
+      identifier: 'lexical-clientComponent',
+      importMap,
+      payloadComponent: ClientComponent
+    });
+    const clientComponentProps = resolvedFeature.clientFeatureProps;
+    if (!ClientComponent) {
+      return null;
+    }
+    return {
+      ClientFeature: clientComponentProps && typeof clientComponentProps === 'object' ? /*#__PURE__*/_createElement(ResolvedClientComponent.Component, {
+        ...clientComponentProps,
+        featureKey: resolvedFeature.key,
+        key: resolvedFeature.key,
+        order: resolvedFeature.order,
+        ...(ResolvedClientComponent?.clientProps || {})
+      }) : /*#__PURE__*/_jsx(ResolvedClientComponent.Component, {
+        featureKey: resolvedFeature.key,
+        order: resolvedFeature.order,
+        ...(ResolvedClientComponent?.clientProps || {})
+      }, resolvedFeature.key),
+      key: resolvedFeature.key,
+      order: resolvedFeature.order
     };
-
+  }).filter(feature => feature !== null));
+  return componentMap;
+};
 //# sourceMappingURL=generateComponentMap.js.map

package/dist/utilities/generateComponentMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/generateComponentMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { mapFields } from '@payloadcms/ui/utilities/buildComponentMap'\nimport React from 'react'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { GeneratedFeatureProviderComponent } from '../types.js'\n\nexport const getGenerateComponentMap =\n  (args: {\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateComponentMap'] =>\n  ({ WithServerSideProps, config, i18n, schemaPath }) => {\n    const componentMap = new Map()\n\n    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n    const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort(\n      (a, b) => a[1].order - b[1].order,\n    )\n\n    componentMap.set(\n      `features`,\n      resolvedFeatureMapArray\n        .map(([featureKey, resolvedFeature]) => {\n          const ClientComponent = resolvedFeature.ClientFeature\n          const clientComponentProps = resolvedFeature.clientFeatureProps\n\n          /**\n           * Handle Feature Component Maps\n           */\n          if (\n            'generateComponentMap' in resolvedFeature &&\n            typeof resolvedFeature.generateComponentMap === 'function'\n          ) {\n            const components = resolvedFeature.generateComponentMap({\n              config,\n              i18n,\n              props: resolvedFeature.sanitizedServerFeatureProps,\n              schemaPath,\n            })\n\n            for (const componentKey in components) {\n              const Component = components[componentKey]\n\n              if (Component) {\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`,\n                  <WithServerSideProps\n                    Component={Component}\n                    componentKey={componentKey}\n                    featureKey={resolvedFeature.key}\n                    key={`${resolvedFeature.key}-${componentKey}`}\n                  />,\n                )\n              }\n            }\n          }\n\n          /**\n           * Handle Feature Schema Maps (rendered fields)\n           */\n          if (\n            'generateSchemaMap' in resolvedFeature &&\n            typeof resolvedFeature.generateSchemaMap === 'function'\n          ) {\n            const schemas = resolvedFeature.generateSchemaMap({\n              config,\n              i18n,\n              props: resolvedFeature.sanitizedServerFeatureProps,\n              schemaMap: new Map(),\n              schemaPath,\n            })\n\n            if (schemas) {\n              for (const [schemaKey, fields] of schemas.entries()) {\n                const mappedFields = mapFields({\n                  WithServerSideProps,\n                  config,\n                  disableAddingID: true,\n                  fieldSchema: fields,\n                  i18n,\n                  parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  readOnly: false,\n                })\n\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  mappedFields,\n                )\n              }\n            }\n          }\n\n          if (!ClientComponent) {\n            return null\n          }\n\n          return {\n            ClientFeature:\n              clientComponentProps && typeof clientComponentProps === 'object' ? (\n                <ClientComponent\n                  {...clientComponentProps}\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ) : (\n                <ClientComponent\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                />\n              ),\n            key: resolvedFeature.key,\n            order: resolvedFeature.order,\n          } as GeneratedFeatureProviderComponent\n        })\n        .filter((feature) => feature !== null),\n    )\n\n    return componentMap\n  }\n"],"names":["mapFields","React","getGenerateComponentMap","args","WithServerSideProps","config","i18n","schemaPath","componentMap","Map","resolvedFeatureMapArray","Array","from","resolvedFeatureMap","entries","sort","a","b","order","set","map","featureKey","resolvedFeature","ClientComponent","ClientFeature","clientComponentProps","clientFeatureProps","generateComponentMap","components","props","sanitizedServerFeatureProps","componentKey","Component","key","generateSchemaMap","schemas","schemaMap","schemaKey","fields","mappedFields","disableAddingID","fieldSchema","parentPath","readOnly","filter","feature"],"mappings":";;AAEA,SAASA,SAAS,QAAQ,6CAA4C;AACtE,OAAOC,WAAW,QAAO;AAKzB,OAAO,MAAMC,0BACX,CAACC,OAGD,CAAC,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,IAAI,EAAEC,UAAU,EAAE;QAChD,MAAMC,eAAe,IAAIC;QAEzB,gHAAgH;QAChH,MAAMC,0BAA0BC,MAAMC,IAAI,CAACT,KAAKU,kBAAkB,CAACC,OAAO,IAAIC,IAAI,CAChF,CAACC,GAAGC,IAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;QAGnCV,aAAaW,GAAG,CACd,CAAC,QAAQ,CAAC,EACVT,wBACGU,GAAG,CAAC,CAAC,CAACC,YAAYC,gBAAgB;YACjC,MAAMC,kBAAkBD,gBAAgBE,aAAa;YACrD,MAAMC,uBAAuBH,gBAAgBI,kBAAkB;YAE/D;;WAEC,GACD,IACE,0BAA0BJ,mBAC1B,OAAOA,gBAAgBK,oBAAoB,KAAK,YAChD;gBACA,MAAMC,aAAaN,gBAAgBK,oBAAoB,CAAC;oBACtDtB;oBACAC;oBACAuB,OAAOP,gBAAgBQ,2BAA2B;oBAClDvB;gBACF;gBAEA,IAAK,MAAMwB,gBAAgBH,WAAY;oBACrC,MAAMI,YAAYJ,UAAU,CAACG,aAAa;oBAE1C,IAAIC,WAAW;wBACbxB,aAAaW,GAAG,CACd,CAAC,yBAAyB,EAAEE,WAAW,6BAA6B,EAAEU,aAAa,CAAC,gBACpF,KAAC3B;4BACC4B,WAAWA;4BACXD,cAAcA;4BACdV,YAAYC,gBAAgBW,GAAG;2BAC1B,CAAC,EAAEX,gBAAgBW,GAAG,CAAC,CAAC,EAAEF,aAAa,CAAC;oBAGnD;gBACF;YACF;YAEA;;WAEC,GACD,IACE,uBAAuBT,mBACvB,OAAOA,gBAAgBY,iBAAiB,KAAK,YAC7C;gBACA,MAAMC,UAAUb,gBAAgBY,iBAAiB,CAAC;oBAChD7B;oBACAC;oBACAuB,OAAOP,gBAAgBQ,2BAA2B;oBAClDM,WAAW,IAAI3B;oBACfF;gBACF;gBAEA,IAAI4B,SAAS;oBACX,KAAK,MAAM,CAACE,WAAWC,OAAO,IAAIH,QAAQrB,OAAO,GAAI;wBACnD,MAAMyB,eAAevC,UAAU;4BAC7BI;4BACAC;4BACAmC,iBAAiB;4BACjBC,aAAaH;4BACbhC;4BACAoC,YAAY,CAAC,EAAEnC,WAAW,0BAA0B,EAAEc,WAAW,QAAQ,EAAEgB,UAAU,CAAC;4BACtFM,UAAU;wBACZ;wBAEAnC,aAAaW,GAAG,CACd,CAAC,yBAAyB,EAAEE,WAAW,QAAQ,EAAEgB,UAAU,CAAC,EAC5DE;oBAEJ;gBACF;YACF;YAEA,IAAI,CAAChB,iBAAiB;gBACpB,OAAO;YACT;YAEA,OAAO;gBACLC,eACEC,wBAAwB,OAAOA,yBAAyB,yBACtD,eAACF;oBACE,GAAGE,oBAAoB;oBACxBJ,YAAYC,gBAAgBW,GAAG;oBAC/BA,KAAKX,gBAAgBW,GAAG;oBACxBf,OAAOI,gBAAgBJ,KAAK;mCAG9B,KAACK;oBACCF,YAAYC,gBAAgBW,GAAG;oBAE/Bf,OAAOI,gBAAgBJ,KAAK;mBADvBI,gBAAgBW,GAAG;gBAI9BA,KAAKX,gBAAgBW,GAAG;gBACxBf,OAAOI,gBAAgBJ,KAAK;YAC9B;QACF,GACC0B,MAAM,CAAC,CAACC,UAAYA,YAAY;QAGrC,OAAOrC;IACT,EAAC"}
+{"version":3,"file":"generateComponentMap.js","names":["getComponent","createClientFields","deepCopyObjectSimple","getGenerateComponentMap","args","createMappedComponent","field","i18n","importMap","payload","schemaPath","componentMap","Map","resolvedFeatureMapArray","Array","from","resolvedFeatureMap","entries","sort","a","b","order","set","map","featureKey","resolvedFeature","components","props","sanitizedServerFeatureProps","componentKey","payloadComponent","mappedComponent","clientProps","key","undefined","generateSchemaMap","schemas","config","schemaMap","schemaKey","fields","clientFields","disableAddingID","parentPath","ClientComponent","ClientFeature","ResolvedClientComponent","identifier","clientComponentProps","clientFeatureProps","_createElement","Component","_jsx","filter","feature"],"sources":["../../src/utilities/generateComponentMap.tsx"],"sourcesContent":["import type { ClientField, MappedComponent, RichTextGenerateComponentMap } from 'payload'\n\nimport { getComponent } from '@payloadcms/ui/shared'\nimport { createClientFields } from '@payloadcms/ui/utilities/createClientConfig'\nimport { deepCopyObjectSimple } from 'payload'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { GeneratedFeatureProviderComponent } from '../types.js'\n\nexport const getGenerateComponentMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextGenerateComponentMap =>\n  ({ createMappedComponent, field, i18n, importMap, payload, schemaPath }) => {\n    const componentMap: Map<\n      string,\n      ClientField[] | GeneratedFeatureProviderComponent[] | MappedComponent\n    > = new Map()\n\n    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n    const resolvedFeatureMapArray = Array.from(args.resolvedFeatureMap.entries()).sort(\n      (a, b) => a[1].order - b[1].order,\n    )\n\n    componentMap.set(\n      `features`,\n      resolvedFeatureMapArray\n        .map(([featureKey, resolvedFeature]) => {\n          /**\n           * Handle Feature Component Maps\n           */\n          if ('componentMap' in resolvedFeature) {\n            const components =\n              typeof resolvedFeature.componentMap === 'function'\n                ? resolvedFeature.componentMap({\n                    i18n,\n                    payload,\n                    props: resolvedFeature.sanitizedServerFeatureProps,\n                    schemaPath,\n                  })\n                : resolvedFeature.componentMap\n\n            for (const componentKey in components) {\n              const payloadComponent = components[componentKey]\n\n              const mappedComponent: MappedComponent = createMappedComponent(\n                payloadComponent,\n                {\n                  clientProps: {\n                    componentKey,\n                    featureKey: resolvedFeature.key,\n                    key: `${resolvedFeature.key}-${componentKey}`,\n                  },\n                },\n                undefined,\n                'lexical-from-resolvedFeature',\n              )\n\n              if (mappedComponent) {\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.lexical_internal_components.${componentKey}`,\n                  mappedComponent,\n                )\n              }\n            }\n          }\n\n          /**\n           * Handle Feature Schema Maps (rendered fields)\n           */\n          if (\n            'generateSchemaMap' in resolvedFeature &&\n            typeof resolvedFeature.generateSchemaMap === 'function'\n          ) {\n            const schemas = resolvedFeature.generateSchemaMap({\n              config: payload.config,\n              field,\n              i18n,\n              props: resolvedFeature.sanitizedServerFeatureProps,\n              schemaMap: new Map(),\n              schemaPath,\n            })\n\n            if (schemas) {\n              for (const [schemaKey, fields] of schemas.entries()) {\n                let clientFields: ClientField[] = deepCopyObjectSimple(\n                  fields,\n                ) as unknown as ClientField[]\n                clientFields = createClientFields({\n                  clientFields,\n                  createMappedComponent,\n                  disableAddingID: true,\n                  fields,\n                  i18n,\n                  importMap,\n                  parentPath: `${schemaPath}.lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  payload,\n                })\n\n                componentMap.set(\n                  `lexical_internal_feature.${featureKey}.fields.${schemaKey}`,\n                  clientFields,\n                )\n              }\n            }\n          }\n\n          const ClientComponent = resolvedFeature.ClientFeature\n          const ResolvedClientComponent = getComponent({\n            identifier: 'lexical-clientComponent',\n            importMap,\n            payloadComponent: ClientComponent,\n          })\n          const clientComponentProps = resolvedFeature.clientFeatureProps\n\n          if (!ClientComponent) {\n            return null\n          }\n\n          return {\n            ClientFeature:\n              clientComponentProps && typeof clientComponentProps === 'object' ? (\n                <ResolvedClientComponent.Component\n                  {...clientComponentProps}\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                  {...(ResolvedClientComponent?.clientProps || {})}\n                />\n              ) : (\n                <ResolvedClientComponent.Component\n                  featureKey={resolvedFeature.key}\n                  key={resolvedFeature.key}\n                  order={resolvedFeature.order}\n                  {...(ResolvedClientComponent?.clientProps || {})}\n                />\n              ),\n            key: resolvedFeature.key,\n            order: resolvedFeature.order,\n          } as GeneratedFeatureProviderComponent\n        })\n        .filter((feature) => feature !== null),\n    )\n\n    return componentMap\n  }\n"],"mappings":";;AAEA,SAASA,YAAY,QAAQ;AAC7B,SAASC,kBAAkB,QAAQ;AACnC,SAASC,oBAAoB,QAAQ;AAKrC,OAAO,MAAMC,uBAAA,GACVC,IAAA,IACD,CAAC;EAAEC,qBAAqB;EAAEC,KAAK;EAAEC,IAAI;EAAEC,SAAS;EAAEC,OAAO;EAAEC;AAAU,CAAE;EACrE,MAAMC,YAAA,GAGF,IAAIC,GAAA;EAER;EACA,MAAMC,uBAAA,GAA0BC,KAAA,CAAMC,IAAI,CAACX,IAAA,CAAKY,kBAAkB,CAACC,OAAO,IAAIC,IAAI,CAChF,CAACC,CAAA,EAAGC,CAAA,KAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;EAGnCV,YAAA,CAAaW,GAAG,CACd,UAAU,EACVT,uBAAA,CACGU,GAAG,CAAC,CAAC,CAACC,UAAA,EAAYC,eAAA,CAAgB;IACjC;;;IAGA,IAAI,kBAAkBA,eAAA,EAAiB;MACrC,MAAMC,UAAA,GACJ,OAAOD,eAAA,CAAgBd,YAAY,KAAK,aACpCc,eAAA,CAAgBd,YAAY,CAAC;QAC3BJ,IAAA;QACAE,OAAA;QACAkB,KAAA,EAAOF,eAAA,CAAgBG,2BAA2B;QAClDlB;MACF,KACAe,eAAA,CAAgBd,YAAY;MAElC,KAAK,MAAMkB,YAAA,IAAgBH,UAAA,EAAY;QACrC,MAAMI,gBAAA,GAAmBJ,UAAU,CAACG,YAAA,CAAa;QAEjD,MAAME,eAAA,GAAmC1B,qBAAA,CACvCyB,gBAAA,EACA;UACEE,WAAA,EAAa;YACXH,YAAA;YACAL,UAAA,EAAYC,eAAA,CAAgBQ,GAAG;YAC/BA,GAAA,EAAK,GAAGR,eAAA,CAAgBQ,GAAG,IAAIJ,YAAA;UACjC;QACF,GACAK,SAAA,EACA;QAGF,IAAIH,eAAA,EAAiB;UACnBpB,YAAA,CAAaW,GAAG,CACd,4BAA4BE,UAAA,gCAA0CK,YAAA,EAAc,EACpFE,eAAA;QAEJ;MACF;IACF;IAEA;;;IAGA,IACE,uBAAuBN,eAAA,IACvB,OAAOA,eAAA,CAAgBU,iBAAiB,KAAK,YAC7C;MACA,MAAMC,OAAA,GAAUX,eAAA,CAAgBU,iBAAiB,CAAC;QAChDE,MAAA,EAAQ5B,OAAA,CAAQ4B,MAAM;QACtB/B,KAAA;QACAC,IAAA;QACAoB,KAAA,EAAOF,eAAA,CAAgBG,2BAA2B;QAClDU,SAAA,EAAW,IAAI1B,GAAA;QACfF;MACF;MAEA,IAAI0B,OAAA,EAAS;QACX,KAAK,MAAM,CAACG,SAAA,EAAWC,MAAA,CAAO,IAAIJ,OAAA,CAAQnB,OAAO,IAAI;UACnD,IAAIwB,YAAA,GAA8BvC,oBAAA,CAChCsC,MAAA;UAEFC,YAAA,GAAexC,kBAAA,CAAmB;YAChCwC,YAAA;YACApC,qBAAA;YACAqC,eAAA,EAAiB;YACjBF,MAAA;YACAjC,IAAA;YACAC,SAAA;YACAmC,UAAA,EAAY,GAAGjC,UAAA,6BAAuCc,UAAA,WAAqBe,SAAA,EAAW;YACtF9B;UACF;UAEAE,YAAA,CAAaW,GAAG,CACd,4BAA4BE,UAAA,WAAqBe,SAAA,EAAW,EAC5DE,YAAA;QAEJ;MACF;IACF;IAEA,MAAMG,eAAA,GAAkBnB,eAAA,CAAgBoB,aAAa;IACrD,MAAMC,uBAAA,GAA0B9C,YAAA,CAAa;MAC3C+C,UAAA,EAAY;MACZvC,SAAA;MACAsB,gBAAA,EAAkBc;IACpB;IACA,MAAMI,oBAAA,GAAuBvB,eAAA,CAAgBwB,kBAAkB;IAE/D,IAAI,CAACL,eAAA,EAAiB;MACpB,OAAO;IACT;IAEA,OAAO;MACLC,aAAA,EACEG,oBAAA,IAAwB,OAAOA,oBAAA,KAAyB,wBACtDE,cAAA,CAACJ,uBAAA,CAAwBK,SAAS;QAC/B,GAAGH,oBAAoB;QACxBxB,UAAA,EAAYC,eAAA,CAAgBQ,GAAG;QAC/BA,GAAA,EAAKR,eAAA,CAAgBQ,GAAG;QACxBZ,KAAA,EAAOI,eAAA,CAAgBJ,KAAK;QAC3B,IAAIyB,uBAAA,EAAyBd,WAAA,IAAe,CAAC,CAAC;wBAGjDoB,IAAA,CAACN,uBAAA,CAAwBK,SAAS;QAChC3B,UAAA,EAAYC,eAAA,CAAgBQ,GAAG;QAE/BZ,KAAA,EAAOI,eAAA,CAAgBJ,KAAK;QAC3B,IAAIyB,uBAAA,EAAyBd,WAAA,IAAe,CAAC,CAAC;SAF1CP,eAAA,CAAgBQ,GAAG;MAK9BA,GAAA,EAAKR,eAAA,CAAgBQ,GAAG;MACxBZ,KAAA,EAAOI,eAAA,CAAgBJ;IACzB;EACF,GACCgC,MAAM,CAAEC,OAAA,IAAYA,OAAA,KAAY;EAGrC,OAAO3C,YAAA;AACT","ignoreList":[]}

package/dist/utilities/generateImportMap.d.ts

@@ -0,0 +1,6 @@
+import type { RichTextAdapter } from 'payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+export declare const getGenerateImportMap: (args: {
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+}) => RichTextAdapter["generateImportMap"];
+//# sourceMappingURL=generateImportMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateImportMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateImportMap.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAmD5F,CAAA"}

package/dist/utilities/generateImportMap.js

@@ -0,0 +1,56 @@
+import { genImportMapIterateFields } from 'payload';
+export const getGenerateImportMap = args => ({
+  addToImportMap,
+  baseDir,
+  config,
+  importMap,
+  imports
+}) => {
+  addToImportMap('@payloadcms/richtext-lexical/client#RichTextCell');
+  addToImportMap('@payloadcms/richtext-lexical/client#RichTextField');
+  addToImportMap('@payloadcms/richtext-lexical/generateComponentMap#getGenerateComponentMap');
+  // iterate just through args.resolvedFeatureMap.values()
+  for (const resolvedFeature of args.resolvedFeatureMap.values()) {
+    if ('componentImports' in resolvedFeature) {
+      if (typeof resolvedFeature.componentImports === 'function') {
+        resolvedFeature.componentImports({
+          addToImportMap,
+          baseDir,
+          config,
+          importMap,
+          imports
+        });
+      } else if (resolvedFeature.componentImports?.length) {
+        resolvedFeature.componentImports.forEach(component => {
+          addToImportMap(component);
+        });
+      }
+    }
+    const ClientComponent = resolvedFeature.ClientFeature;
+    if (ClientComponent) {
+      addToImportMap(ClientComponent);
+    }
+    /*
+    Now run for all possible sub-fields
+    */
+    if (resolvedFeature.nodes?.length) {
+      for (const node of resolvedFeature.nodes) {
+        if (typeof node?.getSubFields !== 'function') {
+          continue;
+        }
+        const subFields = node.getSubFields({});
+        if (subFields?.length) {
+          genImportMapIterateFields({
+            addToImportMap,
+            baseDir,
+            config,
+            fields: subFields,
+            importMap,
+            imports
+          });
+        }
+      }
+    }
+  }
+};
+//# sourceMappingURL=generateImportMap.js.map

package/dist/utilities/generateImportMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateImportMap.js","names":["genImportMapIterateFields","getGenerateImportMap","args","addToImportMap","baseDir","config","importMap","imports","resolvedFeature","resolvedFeatureMap","values","componentImports","length","forEach","component","ClientComponent","ClientFeature","nodes","node","getSubFields","subFields","fields"],"sources":["../../src/utilities/generateImportMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { genImportMapIterateFields } from 'payload'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateImportMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateImportMap'] =>\n  ({ addToImportMap, baseDir, config, importMap, imports }) => {\n    addToImportMap('@payloadcms/richtext-lexical/client#RichTextCell')\n    addToImportMap('@payloadcms/richtext-lexical/client#RichTextField')\n    addToImportMap('@payloadcms/richtext-lexical/generateComponentMap#getGenerateComponentMap')\n\n    // iterate just through args.resolvedFeatureMap.values()\n    for (const resolvedFeature of args.resolvedFeatureMap.values()) {\n      if ('componentImports' in resolvedFeature) {\n        if (typeof resolvedFeature.componentImports === 'function') {\n          resolvedFeature.componentImports({\n            addToImportMap,\n            baseDir,\n            config,\n            importMap,\n            imports,\n          })\n        } else if (resolvedFeature.componentImports?.length) {\n          resolvedFeature.componentImports.forEach((component) => {\n            addToImportMap(component)\n          })\n        }\n      }\n\n      const ClientComponent = resolvedFeature.ClientFeature\n      if (ClientComponent) {\n        addToImportMap(ClientComponent)\n      }\n\n      /*\n        Now run for all possible sub-fields\n       */\n      if (resolvedFeature.nodes?.length) {\n        for (const node of resolvedFeature.nodes) {\n          if (typeof node?.getSubFields !== 'function') {\n            continue\n          }\n          const subFields = node.getSubFields({})\n          if (subFields?.length) {\n            genImportMapIterateFields({\n              addToImportMap,\n              baseDir,\n              config,\n              fields: subFields,\n              importMap,\n              imports,\n            })\n          }\n        }\n      }\n    }\n  }\n"],"mappings":"AAEA,SAASA,yBAAyB,QAAQ;AAI1C,OAAO,MAAMC,oBAAA,GACVC,IAAA,IACD,CAAC;EAAEC,cAAc;EAAEC,OAAO;EAAEC,MAAM;EAAEC,SAAS;EAAEC;AAAO,CAAE;EACtDJ,cAAA,CAAe;EACfA,cAAA,CAAe;EACfA,cAAA,CAAe;EAEf;EACA,KAAK,MAAMK,eAAA,IAAmBN,IAAA,CAAKO,kBAAkB,CAACC,MAAM,IAAI;IAC9D,IAAI,sBAAsBF,eAAA,EAAiB;MACzC,IAAI,OAAOA,eAAA,CAAgBG,gBAAgB,KAAK,YAAY;QAC1DH,eAAA,CAAgBG,gBAAgB,CAAC;UAC/BR,cAAA;UACAC,OAAA;UACAC,MAAA;UACAC,SAAA;UACAC;QACF;MACF,OAAO,IAAIC,eAAA,CAAgBG,gBAAgB,EAAEC,MAAA,EAAQ;QACnDJ,eAAA,CAAgBG,gBAAgB,CAACE,OAAO,CAAEC,SAAA;UACxCX,cAAA,CAAeW,SAAA;QACjB;MACF;IACF;IAEA,MAAMC,eAAA,GAAkBP,eAAA,CAAgBQ,aAAa;IACrD,IAAID,eAAA,EAAiB;MACnBZ,cAAA,CAAeY,eAAA;IACjB;IAEA;;;IAGA,IAAIP,eAAA,CAAgBS,KAAK,EAAEL,MAAA,EAAQ;MACjC,KAAK,MAAMM,IAAA,IAAQV,eAAA,CAAgBS,KAAK,EAAE;QACxC,IAAI,OAAOC,IAAA,EAAMC,YAAA,KAAiB,YAAY;UAC5C;QACF;QACA,MAAMC,SAAA,GAAYF,IAAA,CAAKC,YAAY,CAAC,CAAC;QACrC,IAAIC,SAAA,EAAWR,MAAA,EAAQ;UACrBZ,yBAAA,CAA0B;YACxBG,cAAA;YACAC,OAAA;YACAC,MAAA;YACAgB,MAAA,EAAQD,SAAA;YACRd,SAAA;YACAC;UACF;QACF;MACF;IACF;EACF;AACF","ignoreList":[]}

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

@@ -1 +1 @@
-{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAkC5F,CAAA"}
+{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAmC5F,CAAA"}

package/dist/utilities/generateSchemaMap.js

@@ -1,31 +1,37 @@
 import { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields';
-export const getGenerateSchemaMap = (args)=>({ config, i18n, schemaMap, schemaPath })=>{
-        for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()){
-            if (!('generateSchemaMap' in resolvedFeature) || typeof resolvedFeature.generateSchemaMap !== 'function') {
-                continue;
-            }
-            const schemas = resolvedFeature.generateSchemaMap({
-                config,
-                i18n,
-                props: resolvedFeature.sanitizedServerFeatureProps,
-                schemaMap,
-                schemaPath
-            });
-            if (schemas) {
-                for (const [schemaKey, fields] of schemas.entries()){
-                    // generate schema map entries for sub-fields using traverseFields
-                    traverseFields({
-                        config,
-                        fields,
-                        i18n,
-                        schemaMap: schemas,
-                        schemaPath: schemaKey
-                    });
-                    schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields);
-                }
-            }
-        }
-        return schemaMap;
-    };
-
+export const getGenerateSchemaMap = args => ({
+  config,
+  field,
+  i18n,
+  schemaMap,
+  schemaPath
+}) => {
+  for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {
+    if (!('generateSchemaMap' in resolvedFeature) || typeof resolvedFeature.generateSchemaMap !== 'function') {
+      continue;
+    }
+    const schemas = resolvedFeature.generateSchemaMap({
+      config,
+      field,
+      i18n,
+      props: resolvedFeature.sanitizedServerFeatureProps,
+      schemaMap,
+      schemaPath
+    });
+    if (schemas) {
+      for (const [schemaKey, fields] of schemas.entries()) {
+        // generate schema map entries for sub-fields using traverseFields
+        traverseFields({
+          config,
+          fields,
+          i18n,
+          schemaMap: schemas,
+          schemaPath: schemaKey
+        });
+        schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields);
+      }
+    }
+  }
+  return schemaMap;
+};
 //# sourceMappingURL=generateSchemaMap.js.map

package/dist/utilities/generateSchemaMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, i18n, schemaMap, schemaPath }) => {\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        i18n,\n        props: resolvedFeature.sanitizedServerFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, fields] of schemas.entries()) {\n          // generate schema map entries for sub-fields using traverseFields\n          traverseFields({\n            config,\n            fields,\n            i18n,\n            schemaMap: schemas,\n            schemaPath: schemaKey,\n          })\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["traverseFields","getGenerateSchemaMap","args","config","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","set"],"mappings":"AAEA,SAASA,cAAc,QAAQ,8DAA6D;AAI5F,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QACtC,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIN,KAAKO,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDR;gBACAC;gBACAS,OAAOL,gBAAgBM,2BAA2B;gBAClDT;gBACAC;YACF;YAEA,IAAIM,SAAS;gBACX,KAAK,MAAM,CAACG,WAAWC,OAAO,IAAIJ,QAAQF,OAAO,GAAI;oBACnD,kEAAkE;oBAClEV,eAAe;wBACbG;wBACAa;wBACAZ;wBACAC,WAAWO;wBACXN,YAAYS;oBACd;oBAEAV,UAAUY,GAAG,CAAC,CAAC,EAAEX,WAAW,0BAA0B,EAAEC,WAAW,CAAC,EAAEQ,UAAU,CAAC,EAAEC;gBACrF;YACF;QACF;QAEA,OAAOX;IACT,EAAC"}
+{"version":3,"file":"generateSchemaMap.js","names":["traverseFields","getGenerateSchemaMap","args","config","field","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","set"],"sources":["../../src/utilities/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, field, i18n, schemaMap, schemaPath }) => {\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        field,\n        i18n,\n        props: resolvedFeature.sanitizedServerFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, fields] of schemas.entries()) {\n          // generate schema map entries for sub-fields using traverseFields\n          traverseFields({\n            config,\n            fields,\n            i18n,\n            schemaMap: schemas,\n            schemaPath: schemaKey,\n          })\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"mappings":"AAEA,SAASA,cAAc,QAAQ;AAI/B,OAAO,MAAMC,oBAAA,GACVC,IAAA,IACD,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,IAAI;EAAEC,SAAS;EAAEC;AAAU,CAAE;EAC7C,KAAK,MAAM,CAACC,UAAA,EAAYC,eAAA,CAAgB,IAAIP,IAAA,CAAKQ,kBAAkB,CAACC,OAAO,IAAI;IAC7E,IACE,EAAE,uBAAuBF,eAAc,KACvC,OAAOA,eAAA,CAAgBG,iBAAiB,KAAK,YAC7C;MACA;IACF;IACA,MAAMC,OAAA,GAAUJ,eAAA,CAAgBG,iBAAiB,CAAC;MAChDT,MAAA;MACAC,KAAA;MACAC,IAAA;MACAS,KAAA,EAAOL,eAAA,CAAgBM,2BAA2B;MAClDT,SAAA;MACAC;IACF;IAEA,IAAIM,OAAA,EAAS;MACX,KAAK,MAAM,CAACG,SAAA,EAAWC,MAAA,CAAO,IAAIJ,OAAA,CAAQF,OAAO,IAAI;QACnD;QACAX,cAAA,CAAe;UACbG,MAAA;UACAc,MAAA;UACAZ,IAAA;UACAC,SAAA,EAAWO,OAAA;UACXN,UAAA,EAAYS;QACd;QAEAV,SAAA,CAAUY,GAAG,CAAC,GAAGX,UAAA,6BAAuCC,UAAA,IAAcQ,SAAA,EAAW,EAAEC,MAAA;MACrF;IACF;EACF;EAEA,OAAOX,SAAA;AACT","ignoreList":[]}

package/dist/utilities/migrateSlateToLexical/index.js

@@ -8,98 +8,111 @@ import { migrateDocumentFieldsRecursively } from './migrateDocumentFieldsRecursi
  * - 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
-            });
-        }
+ */
+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
+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
     });
-    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
+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
         });
-        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++;
+      }
     }
+    page++;
+  }
 }
-function migrateDocument({ document, fields }) {
-    return !!migrateDocumentFieldsRecursively({
-        data: document,
-        fields,
-        found: 0
-    });
+function migrateDocument({
+  document,
+  fields
+}) {
+  return !!migrateDocumentFieldsRecursively({
+    data: document,
+    fields,
+    found: 0
+  });
 }
-
 //# sourceMappingURL=index.js.map