@payloadcms/richtext-lexical 3.0.0-beta.9 → 3.0.0-beta.90

package/dist/utilities/generateComponentMap.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+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

@@ -0,0 +1 @@
+{"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":"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","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

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

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

@@ -0,0 +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,CAmC5F,CAAA"}

package/dist/utilities/generateSchemaMap.js

@@ -0,0 +1,37 @@
+import { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields';
+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

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+/**
+ * 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 declare function migrateSlateToLexical({ payload }: {
+    payload: Payload;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/utilities/migrateSlateToLexical/index.js

@@ -0,0 +1,134 @@
+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) {
+    try {
+      await payload.updateGlobal({
+        slug: global.slug,
+        data: document,
+        depth: 0,
+        locale: locale || undefined
+      });
+      // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration
+    } catch (e) {
+      console.log('Error updating global', e, {
+        id: document.id,
+        slug: global.slug
+      });
+    }
+  }
+}
+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) {
+        try {
+          await payload.update({
+            id: document.id,
+            collection: collection.slug,
+            data: document,
+            depth: 0,
+            locale: locale || undefined
+          });
+          // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration
+        } catch (e) {
+          console.log('Error updating collection', e, {
+            id: document.id,
+            slug: collection.slug
+          });
+        }
+      }
+    }
+    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,"file":"index.js","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","e","id","documentCount","count","totalDocs","page","migrated","documents","find","pagination","docs","update"],"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    try {\n      await payload.updateGlobal({\n        slug: global.slug,\n        data: document,\n        depth: 0,\n        locale: locale || undefined,\n      })\n      // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration\n    } catch (e) {\n      console.log('Error updating global', e, {\n        id: document.id,\n        slug: global.slug,\n      })\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        try {\n          await payload.update({\n            id: document.id,\n            collection: collection.slug,\n            data: document,\n            depth: 0,\n            locale: locale || undefined,\n          })\n          // Catch it, because some errors were caused by the user previously (e.g. invalid relationships) and will throw an error now, even though they are not related to the migration\n        } catch (e) {\n          console.log('Error updating collection', e, {\n            id: document.id,\n            slug: collection.slug,\n          })\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"],"mappings":"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","ignoreList":[]}

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;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,MA4E7B,CAAA"}

package/dist/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.js

@@ -0,0 +1,80 @@
+import { fieldAffectsData, fieldHasSubFields, fieldIsArrayType, tabHasName } 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') {
+        found += migrateDocumentFieldsRecursively({
+          data: data[field.name],
+          fields: field.fields,
+          found
+        });
+      } else {
+        found += migrateDocumentFieldsRecursively({
+          data,
+          fields: field.fields,
+          found
+        });
+      }
+    } else if (field.type === 'tabs') {
+      field.tabs.forEach(tab => {
+        found += migrateDocumentFieldsRecursively({
+          data: tabHasName(tab) ? data[tab.name] : data,
+          fields: tab.fields,
+          found
+        });
+      });
+    } 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) {
+            found += migrateDocumentFieldsRecursively({
+              data: data[field.name][i],
+              fields: block.fields,
+              found
+            });
+          }
+        });
+      }
+      if (field.type === 'array') {
+        data[field.name].forEach((_, i) => {
+          found += migrateDocumentFieldsRecursively({
+            data: data[field.name][i],
+            fields: field.fields,
+            found
+          });
+        });
+      }
+    }
+    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 {
+              converters
+            } = slateToLexicalFeature.sanitizedServerFeatureProps;
+            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,"file":"migrateDocumentFieldsRecursively.js","names":["fieldAffectsData","fieldHasSubFields","fieldIsArrayType","tabHasName","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","converters","sanitizedServerFeatureProps","slateData"],"sources":["../../../src/utilities/migrateSlateToLexical/migrateDocumentFieldsRecursively.ts"],"sourcesContent":["import type { Field } from 'payload'\n\nimport { fieldAffectsData, fieldHasSubFields, fieldIsArrayType, tabHasName } from 'payload/shared'\n\nimport type { SlateNodeConverter } 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        found += migrateDocumentFieldsRecursively({\n          data: data[field.name],\n          fields: field.fields,\n          found,\n        })\n      } else {\n        found += migrateDocumentFieldsRecursively({\n          data,\n          fields: field.fields,\n          found,\n        })\n      }\n    } else if (field.type === 'tabs') {\n      field.tabs.forEach((tab) => {\n        found += migrateDocumentFieldsRecursively({\n          data: tabHasName(tab) ? data[tab.name] : data,\n          fields: tab.fields,\n          found,\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            found += migrateDocumentFieldsRecursively({\n              data: data[field.name][i],\n              fields: block.fields,\n              found,\n            })\n          }\n        })\n      }\n\n      if (field.type === 'array') {\n        data[field.name].forEach((_, i) => {\n          found += migrateDocumentFieldsRecursively({\n            data: data[field.name][i],\n            fields: field.fields,\n            found,\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 { converters } = slateToLexicalFeature.sanitizedServerFeatureProps as {\n              converters?: SlateNodeConverter[]\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"],"mappings":"AAEA,SAASA,gBAAgB,EAAEC,iBAAiB,EAAEC,gBAAgB,EAAEC,UAAU,QAAQ;AAKlF,SAASC,qBAAqB,QAAQ;AAStC,OAAO,MAAMC,gCAAA,GAAmCA,CAAC;EAC/CC,IAAI;EACJC,MAAM;EACNC;AAAK,CACoB;EACzB,KAAK,MAAMC,KAAA,IAASF,MAAA,EAAQ;IAC1B,IAAIN,iBAAA,CAAkBQ,KAAA,KAAU,CAACP,gBAAA,CAAiBO,KAAA,GAAQ;MACxD,IAAIT,gBAAA,CAAiBS,KAAA,KAAU,OAAOH,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,KAAK,UAAU;QACnEF,KAAA,IAASH,gCAAA,CAAiC;UACxCC,IAAA,EAAMA,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC;UACtBH,MAAA,EAAQE,KAAA,CAAMF,MAAM;UACpBC;QACF;MACF,OAAO;QACLA,KAAA,IAASH,gCAAA,CAAiC;UACxCC,IAAA;UACAC,MAAA,EAAQE,KAAA,CAAMF,MAAM;UACpBC;QACF;MACF;IACF,OAAO,IAAIC,KAAA,CAAME,IAAI,KAAK,QAAQ;MAChCF,KAAA,CAAMG,IAAI,CAACC,OAAO,CAAEC,GAAA;QAClBN,KAAA,IAASH,gCAAA,CAAiC;UACxCC,IAAA,EAAMH,UAAA,CAAWW,GAAA,IAAOR,IAAI,CAACQ,GAAA,CAAIJ,IAAI,CAAC,GAAGJ,IAAA;UACzCC,MAAA,EAAQO,GAAA,CAAIP,MAAM;UAClBC;QACF;MACF;IACF,OAAO,IAAIO,KAAA,CAAMC,OAAO,CAACV,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,GAAG;MAC1C,IAAID,KAAA,CAAME,IAAI,KAAK,UAAU;QAC3BL,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACI,GAAA,EAAKC,CAAA;UAC7B,MAAMC,KAAA,GAAQV,KAAA,CAAMW,MAAM,CAACC,IAAI,CAAC,CAAC;YAAEC;UAAI,CAAE,KAAKA,IAAA,KAASL,GAAA,EAAKM,SAAA;UAC5D,IAAIJ,KAAA,EAAO;YACTX,KAAA,IAASH,gCAAA,CAAiC;cACxCC,IAAA,EAAMA,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,CAACQ,CAAA,CAAE;cACzBX,MAAA,EAAQY,KAAA,CAAMZ,MAAM;cACpBC;YACF;UACF;QACF;MACF;MAEA,IAAIC,KAAA,CAAME,IAAI,KAAK,SAAS;QAC1BL,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,CAACG,OAAO,CAAC,CAACW,CAAA,EAAGN,CAAA;UAC3BV,KAAA,IAASH,gCAAA,CAAiC;YACxCC,IAAA,EAAMA,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,CAACQ,CAAA,CAAE;YACzBX,MAAA,EAAQE,KAAA,CAAMF,MAAM;YACpBC;UACF;QACF;MACF;IACF;IAEA,IAAIC,KAAA,CAAME,IAAI,KAAK,cAAcI,KAAA,CAAMC,OAAO,CAACV,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,GAAG;MAChE;MACA,MAAMe,MAAA,GAAiChB,KAAA,CAAMgB,MAAM;MACnD,IAAIA,MAAA,IAAU,OAAOA,MAAA,KAAW,UAAU;QACxC,IAAI,cAAcA,MAAA,IAAUA,MAAA,CAAOC,QAAQ,EAAEC,MAAA,EAAQ;UACnD;UACA,MAAMC,qBAAA,GAAwBH,MAAA,CAAOI,YAAY,CAACC,kBAAkB,CAACC,GAAG,CAAC;UACzE,IAAIH,qBAAA,EAAuB;YACzB;YAEA,MAAM;cAAEI;YAAU,CAAE,GAAGJ,qBAAA,CAAsBK,2BAA2B;YAIxE3B,IAAI,CAACG,KAAA,CAAMC,IAAI,CAAC,GAAGN,qBAAA,CAAsB;cACvC4B,UAAA;cACAE,SAAA,EAAW5B,IAAI,CAACG,KAAA,CAAMC,IAAI;YAC5B;YAEAF,KAAA;UACF;QACF;MACF;IACF;EACF;EAEA,OAAOA,KAAA;AACT","ignoreList":[]}

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,30 @@
+// 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,"file":"recurseNodeTree.js","names":["recurseNodeTree","flattenedNodes","nodeIDMap","nodes","length","node","push","id","fields","Array","isArray","children"],"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"],"mappings":"AAEA;AACA,OAAO,MAAMA,eAAA,GAAkBA,CAAC;EAC9BC,cAAc;EACdC,SAAS;EACTC;AAAK,CAON;EACC,IAAI,CAACA,KAAA,EAAOC,MAAA,EAAQ;IAClB;EACF;EAEA,KAAK,MAAMC,IAAA,IAAQF,KAAA,EAAO;IACxB,IAAIF,cAAA,EAAgB;MAClBA,cAAA,CAAeK,IAAI,CAACD,IAAA;IACtB;IACA,IAAIH,SAAA,EAAW;MACb,IAAIG,IAAA,IAAQ,QAAQA,IAAA,IAAQA,IAAA,CAAKE,EAAE,EAAE;QACnCL,SAAS,CAACG,IAAA,CAAKE,EAAE,CAAW,GAAGF,IAAA;MACjC,OAAO,IACL,YAAYA,IAAA,IACZ,OAAOA,IAAA,CAAKG,MAAM,KAAK,YACvBH,IAAA,CAAKG,MAAM,IACX,QAAQH,IAAA,CAAKG,MAAM,IACnBH,IAAA,EAAMG,MAAA,EAAQD,EAAA,EACd;QACAL,SAAS,CAACG,IAAA,CAAKG,MAAM,CAACD,EAAE,CAAW,GAAGF,IAAA;MACxC;IACF;IAEA,IAAI,cAAcA,IAAA,IAAQI,KAAA,CAAMC,OAAO,CAACL,IAAA,EAAMM,QAAA,KAAaN,IAAA,EAAMM,QAAA,EAAUP,MAAA,EAAQ;MACjFJ,eAAA,CAAgB;QACdC,cAAA;QACAC,SAAA;QACAC,KAAA,EAAOE,IAAA,CAAKM;MACd;IACF;EACF;AACF","ignoreList":[]}

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