@payloadcms/richtext-lexical 3.71.0-internal-debug.e053082 → 3.71.0-internal.49c4f67

package/dist/utilities/generateImportMap.js

@@ -1,46 +1,52 @@
 import { genImportMapIterateFields } from 'payload';
-export const getGenerateImportMap = (args)=>({ addToImportMap, baseDir, config, importMap, imports })=>{
-        addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell');
-        addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField');
-        addToImportMap('@payloadcms/richtext-lexical/rsc#LexicalDiffComponent');
-        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 (Array.isArray(resolvedFeature.componentImports)) {
-                    addToImportMap(resolvedFeature.componentImports);
-                } else if (typeof resolvedFeature.componentImports === 'object') {
-                    addToImportMap(Object.values(resolvedFeature.componentImports));
-                }
-            }
-            addToImportMap(resolvedFeature.ClientFeature);
-            /*
-       * 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
-                        });
-                    }
-                }
-            }
+export const getGenerateImportMap = args => ({
+  addToImportMap,
+  baseDir,
+  config,
+  importMap,
+  imports
+}) => {
+  addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell');
+  addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField');
+  addToImportMap('@payloadcms/richtext-lexical/rsc#LexicalDiffComponent');
+  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 (Array.isArray(resolvedFeature.componentImports)) {
+        addToImportMap(resolvedFeature.componentImports);
+      } else if (typeof resolvedFeature.componentImports === 'object') {
+        addToImportMap(Object.values(resolvedFeature.componentImports));
+      }
+    }
+    addToImportMap(resolvedFeature.ClientFeature);
+    /*
+    * 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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/generateImportMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { genImportMapIterateFields } from 'payload'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { LexicalEditorProps } from '../types.js'\n\nexport const getGenerateImportMap =\n  (args: {\n    lexicalEditorArgs?: LexicalEditorProps\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateImportMap'] =>\n  ({ addToImportMap, baseDir, config, importMap, imports }) => {\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell')\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField')\n    addToImportMap('@payloadcms/richtext-lexical/rsc#LexicalDiffComponent')\n\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 (Array.isArray(resolvedFeature.componentImports)) {\n          addToImportMap(resolvedFeature.componentImports)\n        } else if (typeof resolvedFeature.componentImports === 'object') {\n          addToImportMap(Object.values(resolvedFeature.componentImports))\n        }\n      }\n\n      addToImportMap(resolvedFeature.ClientFeature)\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"],"names":["genImportMapIterateFields","getGenerateImportMap","args","addToImportMap","baseDir","config","importMap","imports","resolvedFeature","resolvedFeatureMap","values","componentImports","Array","isArray","Object","ClientFeature","nodes","length","node","getSubFields","subFields","fields"],"mappings":"AAEA,SAASA,yBAAyB,QAAQ,UAAS;AAKnD,OAAO,MAAMC,uBACX,CAACC,OAID,CAAC,EAAEC,cAAc,EAAEC,OAAO,EAAEC,MAAM,EAAEC,SAAS,EAAEC,OAAO,EAAE;QACtDJ,eAAe;QACfA,eAAe;QACfA,eAAe;QAEf,KAAK,MAAMK,mBAAmBN,KAAKO,kBAAkB,CAACC,MAAM,GAAI;YAC9D,IAAI,sBAAsBF,iBAAiB;gBACzC,IAAI,OAAOA,gBAAgBG,gBAAgB,KAAK,YAAY;oBAC1DH,gBAAgBG,gBAAgB,CAAC;wBAC/BR;wBACAC;wBACAC;wBACAC;wBACAC;oBACF;gBACF,OAAO,IAAIK,MAAMC,OAAO,CAACL,gBAAgBG,gBAAgB,GAAG;oBAC1DR,eAAeK,gBAAgBG,gBAAgB;gBACjD,OAAO,IAAI,OAAOH,gBAAgBG,gBAAgB,KAAK,UAAU;oBAC/DR,eAAeW,OAAOJ,MAAM,CAACF,gBAAgBG,gBAAgB;gBAC/D;YACF;YAEAR,eAAeK,gBAAgBO,aAAa;YAE5C;;OAEC,GACD,IAAIP,gBAAgBQ,KAAK,EAAEC,QAAQ;gBACjC,KAAK,MAAMC,QAAQV,gBAAgBQ,KAAK,CAAE;oBACxC,IAAI,OAAOE,MAAMC,iBAAiB,YAAY;wBAC5C;oBACF;oBACA,MAAMC,YAAYF,KAAKC,YAAY,CAAC,CAAC;oBACrC,IAAIC,WAAWH,QAAQ;wBACrBjB,0BAA0B;4BACxBG;4BACAC;4BACAC;4BACAgB,QAAQD;4BACRd;4BACAC;wBACF;oBACF;gBACF;YACF;QACF;IACF,EAAC"}
+{"version":3,"file":"generateImportMap.js","names":["genImportMapIterateFields","getGenerateImportMap","args","addToImportMap","baseDir","config","importMap","imports","resolvedFeature","resolvedFeatureMap","values","componentImports","Array","isArray","Object","ClientFeature","nodes","length","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'\nimport type { LexicalEditorProps } from '../types.js'\n\nexport const getGenerateImportMap =\n  (args: {\n    lexicalEditorArgs?: LexicalEditorProps\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateImportMap'] =>\n  ({ addToImportMap, baseDir, config, importMap, imports }) => {\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell')\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField')\n    addToImportMap('@payloadcms/richtext-lexical/rsc#LexicalDiffComponent')\n\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 (Array.isArray(resolvedFeature.componentImports)) {\n          addToImportMap(resolvedFeature.componentImports)\n        } else if (typeof resolvedFeature.componentImports === 'object') {\n          addToImportMap(Object.values(resolvedFeature.componentImports))\n        }\n      }\n\n      addToImportMap(resolvedFeature.ClientFeature)\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;AAK1C,OAAO,MAAMC,oBAAA,GACVC,IAAA,IAID,CAAC;EAAEC,cAAc;EAAEC,OAAO;EAAEC,MAAM;EAAEC,SAAS;EAAEC;AAAO,CAAE;EACtDJ,cAAA,CAAe;EACfA,cAAA,CAAe;EACfA,cAAA,CAAe;EAEf,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,IAAIK,KAAA,CAAMC,OAAO,CAACL,eAAA,CAAgBG,gBAAgB,GAAG;QAC1DR,cAAA,CAAeK,eAAA,CAAgBG,gBAAgB;MACjD,OAAO,IAAI,OAAOH,eAAA,CAAgBG,gBAAgB,KAAK,UAAU;QAC/DR,cAAA,CAAeW,MAAA,CAAOJ,MAAM,CAACF,eAAA,CAAgBG,gBAAgB;MAC/D;IACF;IAEAR,cAAA,CAAeK,eAAA,CAAgBO,aAAa;IAE5C;;;IAGA,IAAIP,eAAA,CAAgBQ,KAAK,EAAEC,MAAA,EAAQ;MACjC,KAAK,MAAMC,IAAA,IAAQV,eAAA,CAAgBQ,KAAK,EAAE;QACxC,IAAI,OAAOE,IAAA,EAAMC,YAAA,KAAiB,YAAY;UAC5C;QACF;QACA,MAAMC,SAAA,GAAYF,IAAA,CAAKC,YAAY,CAAC,CAAC;QACrC,IAAIC,SAAA,EAAWH,MAAA,EAAQ;UACrBjB,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.js

@@ -1,35 +1,40 @@
 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, field] of schemas.entries()){
-                    if ('fields' in field) {
-                        // generate schema map entries for sub-fields using traverseFields
-                        traverseFields({
-                            config,
-                            fields: field.fields,
-                            i18n,
-                            parentIndexPath: '',
-                            parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,
-                            schemaMap
-                        });
-                    }
-                    schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field);
-                }
-            }
+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, field] of schemas.entries()) {
+        if ('fields' in field) {
+          // generate schema map entries for sub-fields using traverseFields
+          traverseFields({
+            config,
+            fields: field.fields,
+            i18n,
+            parentIndexPath: '',
+            parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,
+            schemaMap
+          });
         }
-        return schemaMap;
-    };
-
+        schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field);
+      }
+    }
+  }
+  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, 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, field] of schemas.entries()) {\n          if ('fields' in field) {\n            // generate schema map entries for sub-fields using traverseFields\n            traverseFields({\n              config,\n              fields: field.fields,\n              i18n,\n              parentIndexPath: '',\n              parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,\n              schemaMap,\n            })\n          }\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["traverseFields","getGenerateSchemaMap","args","config","field","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","parentIndexPath","parentSchemaPath","set"],"mappings":"AAEA,SAASA,cAAc,QAAQ,8DAA6D;AAI5F,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QAC7C,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIP,KAAKQ,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDT;gBACAC;gBACAC;gBACAS,OAAOL,gBAAgBM,2BAA2B;gBAClDT;gBACAC;YACF;YAEA,IAAIM,SAAS;gBACX,KAAK,MAAM,CAACG,WAAWZ,MAAM,IAAIS,QAAQF,OAAO,GAAI;oBAClD,IAAI,YAAYP,OAAO;wBACrB,kEAAkE;wBAClEJ,eAAe;4BACbG;4BACAc,QAAQb,MAAMa,MAAM;4BACpBZ;4BACAa,iBAAiB;4BACjBC,kBAAkB,GAAGZ,WAAW,0BAA0B,EAAEC,WAAW,CAAC,EAAEQ,WAAW;4BACrFV;wBACF;oBACF;oBAEAA,UAAUc,GAAG,CAAC,GAAGb,WAAW,0BAA0B,EAAEC,WAAW,CAAC,EAAEQ,WAAW,EAAEZ;gBACrF;YACF;QACF;QAEA,OAAOE;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","parentIndexPath","parentSchemaPath","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, field] of schemas.entries()) {\n          if ('fields' in field) {\n            // generate schema map entries for sub-fields using traverseFields\n            traverseFields({\n              config,\n              fields: field.fields,\n              i18n,\n              parentIndexPath: '',\n              parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,\n              schemaMap,\n            })\n          }\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field)\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,EAAWZ,KAAA,CAAM,IAAIS,OAAA,CAAQF,OAAO,IAAI;QAClD,IAAI,YAAYP,KAAA,EAAO;UACrB;UACAJ,cAAA,CAAe;YACbG,MAAA;YACAc,MAAA,EAAQb,KAAA,CAAMa,MAAM;YACpBZ,IAAA;YACAa,eAAA,EAAiB;YACjBC,gBAAA,EAAkB,GAAGZ,UAAA,6BAAuCC,UAAA,IAAcQ,SAAA,EAAW;YACrFV;UACF;QACF;QAEAA,SAAA,CAAUc,GAAG,CAAC,GAAGb,UAAA,6BAAuCC,UAAA,IAAcQ,SAAA,EAAW,EAAEZ,KAAA;MACrF;IACF;EACF;EAEA,OAAOE,SAAA;AACT","ignoreList":[]}

package/dist/utilities/getDefaultSanitizedEditorConfig.js

@@ -2,18 +2,20 @@ import { defaultEditorConfig } from '../lexical/config/server/default.js';
 import { sanitizeServerEditorConfig } from '../lexical/config/server/sanitize.js';
 let cachedDefaultSanitizedServerEditorConfig = global._payload_lexical_defaultSanitizedServerEditorConfig;
 if (!cachedDefaultSanitizedServerEditorConfig) {
-    cachedDefaultSanitizedServerEditorConfig = global._payload_lexical_defaultSanitizedServerEditorConfig = null;
+  cachedDefaultSanitizedServerEditorConfig = global._payload_lexical_defaultSanitizedServerEditorConfig = null;
 }
-export const getDefaultSanitizedEditorConfig = async (args)=>{
-    const { config, parentIsLocalized } = args;
-    if (cachedDefaultSanitizedServerEditorConfig) {
-        return await cachedDefaultSanitizedServerEditorConfig;
-    }
-    cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig, config, parentIsLocalized);
-    global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
-    cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig;
-    global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
-    return cachedDefaultSanitizedServerEditorConfig;
+export const getDefaultSanitizedEditorConfig = async args => {
+  const {
+    config,
+    parentIsLocalized
+  } = args;
+  if (cachedDefaultSanitizedServerEditorConfig) {
+    return await cachedDefaultSanitizedServerEditorConfig;
+  }
+  cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig, config, parentIsLocalized);
+  global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
+  cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig;
+  global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
+  return cachedDefaultSanitizedServerEditorConfig;
 };
-
 //# sourceMappingURL=getDefaultSanitizedEditorConfig.js.map

package/dist/utilities/getDefaultSanitizedEditorConfig.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getDefaultSanitizedEditorConfig.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport { type SanitizedServerEditorConfig } from '../index.js'\nimport { defaultEditorConfig } from '../lexical/config/server/default.js'\nimport { sanitizeServerEditorConfig } from '../lexical/config/server/sanitize.js'\n\nlet cachedDefaultSanitizedServerEditorConfig:\n  | null\n  | Promise<SanitizedServerEditorConfig>\n  | SanitizedServerEditorConfig = (global as any)\n  ._payload_lexical_defaultSanitizedServerEditorConfig\n\nif (!cachedDefaultSanitizedServerEditorConfig) {\n  cachedDefaultSanitizedServerEditorConfig = (\n    global as any\n  )._payload_lexical_defaultSanitizedServerEditorConfig = null\n}\n\nexport const getDefaultSanitizedEditorConfig = async (args: {\n  config: SanitizedConfig\n  parentIsLocalized: boolean\n}): Promise<SanitizedServerEditorConfig> => {\n  const { config, parentIsLocalized } = args\n\n  if (cachedDefaultSanitizedServerEditorConfig) {\n    return await cachedDefaultSanitizedServerEditorConfig\n  }\n\n  cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(\n    defaultEditorConfig,\n    config,\n    parentIsLocalized,\n  )\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  return cachedDefaultSanitizedServerEditorConfig\n}\n"],"names":["defaultEditorConfig","sanitizeServerEditorConfig","cachedDefaultSanitizedServerEditorConfig","global","_payload_lexical_defaultSanitizedServerEditorConfig","getDefaultSanitizedEditorConfig","args","config","parentIsLocalized","payload_lexical_defaultSanitizedServerEditorConfig"],"mappings":"AAGA,SAASA,mBAAmB,QAAQ,sCAAqC;AACzE,SAASC,0BAA0B,QAAQ,uCAAsC;AAEjF,IAAIC,2CAG8B,AAACC,OAChCC,mDAAmD;AAEtD,IAAI,CAACF,0CAA0C;IAC7CA,2CAA2C,AACzCC,OACAC,mDAAmD,GAAG;AAC1D;AAEA,OAAO,MAAMC,kCAAkC,OAAOC;IAIpD,MAAM,EAAEC,MAAM,EAAEC,iBAAiB,EAAE,GAAGF;IAEtC,IAAIJ,0CAA0C;QAC5C,OAAO,MAAMA;IACf;IAEAA,2CAA2CD,2BACzCD,qBACAO,QACAC;IAEAL,OAAeM,kDAAkD,GACjEP;IAEFA,2CAA2C,MAAMA;IAC/CC,OAAeM,kDAAkD,GACjEP;IAEF,OAAOA;AACT,EAAC"}
+{"version":3,"file":"getDefaultSanitizedEditorConfig.js","names":["defaultEditorConfig","sanitizeServerEditorConfig","cachedDefaultSanitizedServerEditorConfig","global","_payload_lexical_defaultSanitizedServerEditorConfig","getDefaultSanitizedEditorConfig","args","config","parentIsLocalized","payload_lexical_defaultSanitizedServerEditorConfig"],"sources":["../../src/utilities/getDefaultSanitizedEditorConfig.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport { type SanitizedServerEditorConfig } from '../index.js'\nimport { defaultEditorConfig } from '../lexical/config/server/default.js'\nimport { sanitizeServerEditorConfig } from '../lexical/config/server/sanitize.js'\n\nlet cachedDefaultSanitizedServerEditorConfig:\n  | null\n  | Promise<SanitizedServerEditorConfig>\n  | SanitizedServerEditorConfig = (global as any)\n  ._payload_lexical_defaultSanitizedServerEditorConfig\n\nif (!cachedDefaultSanitizedServerEditorConfig) {\n  cachedDefaultSanitizedServerEditorConfig = (\n    global as any\n  )._payload_lexical_defaultSanitizedServerEditorConfig = null\n}\n\nexport const getDefaultSanitizedEditorConfig = async (args: {\n  config: SanitizedConfig\n  parentIsLocalized: boolean\n}): Promise<SanitizedServerEditorConfig> => {\n  const { config, parentIsLocalized } = args\n\n  if (cachedDefaultSanitizedServerEditorConfig) {\n    return await cachedDefaultSanitizedServerEditorConfig\n  }\n\n  cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(\n    defaultEditorConfig,\n    config,\n    parentIsLocalized,\n  )\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  return cachedDefaultSanitizedServerEditorConfig\n}\n"],"mappings":"AAGA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,0BAA0B,QAAQ;AAE3C,IAAIC,wCAAA,GAG8BC,MAAC,CAChCC,mDAAmD;AAEtD,IAAI,CAACF,wCAAA,EAA0C;EAC7CA,wCAAA,GAA2CC,MACzC,CACAC,mDAAmD,GAAG;AAC1D;AAEA,OAAO,MAAMC,+BAAA,GAAkC,MAAOC,IAAA;EAIpD,MAAM;IAAEC,MAAM;IAAEC;EAAiB,CAAE,GAAGF,IAAA;EAEtC,IAAIJ,wCAAA,EAA0C;IAC5C,OAAO,MAAMA,wCAAA;EACf;EAEAA,wCAAA,GAA2CD,0BAAA,CACzCD,mBAAA,EACAO,MAAA,EACAC,iBAAA;EAEAL,MAAA,CAAeM,kDAAkD,GACjEP,wCAAA;EAEFA,wCAAA,GAA2C,MAAMA,wCAAA;EAC/CC,MAAA,CAAeM,kDAAkD,GACjEP,wCAAA;EAEF,OAAOA,wCAAA;AACT","ignoreList":[]}

package/dist/utilities/initLexicalFeatures.js

@@ -1,75 +1,72 @@
 import { getFromImportMap } from 'payload/shared';
 export function initLexicalFeatures(args) {
-    const clientFeatures = {};
-    // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
-    const resolvedFeatureMapArray = [
-        ...args.sanitizedEditorConfig.resolvedFeatureMap
-    ].sort((a, b)=>a[1].order - b[1].order);
-    const featureClientSchemaMap = {};
+  const clientFeatures = {};
+  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
+  const resolvedFeatureMapArray = [...args.sanitizedEditorConfig.resolvedFeatureMap].sort((a, b) => a[1].order - b[1].order);
+  const featureClientSchemaMap = {};
+  /**
+  * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used
+  */
+  const featureClientImportMap = {};
+  for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray) {
+    clientFeatures[featureKey] = {};
     /**
-   * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used
-   */ const featureClientImportMap = {};
-    for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray){
-        clientFeatures[featureKey] = {};
-        /**
-     * Handle client features
-     */ const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature;
-        if (ClientFeaturePayloadComponent) {
-            const clientFeatureProvider = getFromImportMap({
-                importMap: args.payload.importMap,
-                PayloadComponent: ClientFeaturePayloadComponent,
-                schemaPath: 'lexical-clientComponent',
-                silent: true
-            });
-            if (!clientFeatureProvider) {
-                continue;
-            }
-            const clientFeatureProps = resolvedFeature.clientFeatureProps ?? {};
-            clientFeatureProps.featureKey = resolvedFeature.key;
-            clientFeatureProps.order = resolvedFeature.order;
-            if (typeof ClientFeaturePayloadComponent === 'object' && ClientFeaturePayloadComponent.clientProps) {
-                clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps;
-            }
-            // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props
-            clientFeatures[featureKey] = {
-                clientFeatureProps,
-                clientFeatureProvider
-            };
-        }
-        /**
-     * Handle sub-fields (formstate of those)
-     */ // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas
-        // as well, as it already called feature.generateSchemaMap for each feature.
-        // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here
-        if (resolvedFeature.generateSchemaMap) {
-            const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`;
-            featureClientSchemaMap[featureKey] = {};
-            // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature
-            for (const [key, entry] of args.clientFieldSchemaMap.entries()){
-                if (key.startsWith(featureSchemaPath)) {
-                    featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [
-                        entry
-                    ];
-                }
-            }
-        }
-        if (resolvedFeature.componentImports && typeof resolvedFeature.componentImports === 'object' && !Array.isArray(resolvedFeature.componentImports)) {
-            for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)){
-                const resolvedComponent = getFromImportMap({
-                    importMap: args.payload.importMap,
-                    PayloadComponent: payloadComponent,
-                    schemaPath: 'lexical-clientComponent',
-                    silent: true
-                });
-                featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent;
-            }
+    * Handle client features
+    */
+    const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature;
+    if (ClientFeaturePayloadComponent) {
+      const clientFeatureProvider = getFromImportMap({
+        importMap: args.payload.importMap,
+        PayloadComponent: ClientFeaturePayloadComponent,
+        schemaPath: 'lexical-clientComponent',
+        silent: true
+      });
+      if (!clientFeatureProvider) {
+        continue;
+      }
+      const clientFeatureProps = resolvedFeature.clientFeatureProps ?? {};
+      clientFeatureProps.featureKey = resolvedFeature.key;
+      clientFeatureProps.order = resolvedFeature.order;
+      if (typeof ClientFeaturePayloadComponent === 'object' && ClientFeaturePayloadComponent.clientProps) {
+        clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps;
+      }
+      // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props
+      clientFeatures[featureKey] = {
+        clientFeatureProps,
+        clientFeatureProvider
+      };
+    }
+    /**
+    * Handle sub-fields (formstate of those)
+    */ // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas
+    // as well, as it already called feature.generateSchemaMap for each feature.
+    // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here
+    if (resolvedFeature.generateSchemaMap) {
+      const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`;
+      featureClientSchemaMap[featureKey] = {};
+      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature
+      for (const [key, entry] of args.clientFieldSchemaMap.entries()) {
+        if (key.startsWith(featureSchemaPath)) {
+          featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [entry];
         }
+      }
+    }
+    if (resolvedFeature.componentImports && typeof resolvedFeature.componentImports === 'object' && !Array.isArray(resolvedFeature.componentImports)) {
+      for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)) {
+        const resolvedComponent = getFromImportMap({
+          importMap: args.payload.importMap,
+          PayloadComponent: payloadComponent,
+          schemaPath: 'lexical-clientComponent',
+          silent: true
+        });
+        featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent;
+      }
     }
-    return {
-        clientFeatures,
-        featureClientImportMap,
-        featureClientSchemaMap
-    };
+  }
+  return {
+    clientFeatures,
+    featureClientImportMap,
+    featureClientSchemaMap
+  };
 }
-
 //# sourceMappingURL=initLexicalFeatures.js.map

package/dist/utilities/initLexicalFeatures.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/initLexicalFeatures.ts"],"sourcesContent":["import type { I18nClient } from '@payloadcms/translations'\n\nimport { type ClientFieldSchemaMap, type FieldSchemaMap, type Payload } from 'payload'\nimport { getFromImportMap } from 'payload/shared'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from '../features/typesClient.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js'\ntype Args = {\n  clientFieldSchemaMap: ClientFieldSchemaMap\n  fieldSchemaMap: FieldSchemaMap\n  i18n: I18nClient\n  path: string\n  payload: Payload\n  sanitizedEditorConfig: SanitizedServerEditorConfig\n  schemaPath: string\n}\n\nexport function initLexicalFeatures(args: Args): {\n  clientFeatures: LexicalRichTextFieldProps['clientFeatures']\n  featureClientImportMap: Record<string, any>\n  featureClientSchemaMap: FeatureClientSchemaMap\n} {\n  const clientFeatures: LexicalRichTextFieldProps['clientFeatures'] = {}\n\n  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n  const resolvedFeatureMapArray = [...args.sanitizedEditorConfig.resolvedFeatureMap].sort(\n    (a, b) => a[1].order - b[1].order,\n  )\n\n  const featureClientSchemaMap: FeatureClientSchemaMap = {}\n\n  /**\n   * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used\n   */\n  const featureClientImportMap: Record<string, any> | undefined = {}\n\n  for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray) {\n    clientFeatures[featureKey] = {}\n\n    /**\n     * Handle client features\n     */\n    const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature\n\n    if (ClientFeaturePayloadComponent) {\n      const clientFeatureProvider = getFromImportMap<FeatureProviderProviderClient>({\n        importMap: args.payload.importMap,\n        PayloadComponent: ClientFeaturePayloadComponent,\n        schemaPath: 'lexical-clientComponent',\n        silent: true,\n      })\n\n      if (!clientFeatureProvider) {\n        continue\n      }\n\n      const clientFeatureProps: BaseClientFeatureProps<Record<string, any>> =\n        resolvedFeature.clientFeatureProps ?? {}\n      clientFeatureProps.featureKey = resolvedFeature.key\n      clientFeatureProps.order = resolvedFeature.order\n      if (\n        typeof ClientFeaturePayloadComponent === 'object' &&\n        ClientFeaturePayloadComponent.clientProps\n      ) {\n        clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps\n      }\n      // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props\n      clientFeatures[featureKey] = { clientFeatureProps, clientFeatureProvider }\n    }\n\n    /**\n     * Handle sub-fields (formstate of those)\n     */\n    // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas\n    // as well, as it already called feature.generateSchemaMap for each feature.\n    // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here\n    if (resolvedFeature.generateSchemaMap) {\n      const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`\n\n      featureClientSchemaMap[featureKey] = {}\n\n      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature\n      for (const [key, entry] of args.clientFieldSchemaMap.entries()) {\n        if (key.startsWith(featureSchemaPath)) {\n          featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [entry]\n        }\n      }\n    }\n\n    if (\n      resolvedFeature.componentImports &&\n      typeof resolvedFeature.componentImports === 'object' &&\n      !Array.isArray(resolvedFeature.componentImports)\n    ) {\n      for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)) {\n        const resolvedComponent = getFromImportMap({\n          importMap: args.payload.importMap,\n          PayloadComponent: payloadComponent,\n          schemaPath: 'lexical-clientComponent',\n          silent: true,\n        })\n\n        featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent\n      }\n    }\n  }\n  return {\n    clientFeatures,\n    featureClientImportMap,\n    featureClientSchemaMap,\n  }\n}\n"],"names":["getFromImportMap","initLexicalFeatures","args","clientFeatures","resolvedFeatureMapArray","sanitizedEditorConfig","resolvedFeatureMap","sort","a","b","order","featureClientSchemaMap","featureClientImportMap","featureKey","resolvedFeature","ClientFeaturePayloadComponent","ClientFeature","clientFeatureProvider","importMap","payload","PayloadComponent","schemaPath","silent","clientFeatureProps","key","clientProps","generateSchemaMap","featureSchemaPath","entry","clientFieldSchemaMap","entries","startsWith","fields","componentImports","Array","isArray","payloadComponent","Object","resolvedComponent"],"mappings":"AAGA,SAASA,gBAAgB,QAAQ,iBAAgB;AAkBjD,OAAO,SAASC,oBAAoBC,IAAU;IAK5C,MAAMC,iBAA8D,CAAC;IAErE,gHAAgH;IAChH,MAAMC,0BAA0B;WAAIF,KAAKG,qBAAqB,CAACC,kBAAkB;KAAC,CAACC,IAAI,CACrF,CAACC,GAAGC,IAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;IAGnC,MAAMC,yBAAiD,CAAC;IAExD;;GAEC,GACD,MAAMC,yBAA0D,CAAC;IAEjE,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIV,wBAAyB;QACnED,cAAc,CAACU,WAAW,GAAG,CAAC;QAE9B;;KAEC,GACD,MAAME,gCAAgCD,gBAAgBE,aAAa;QAEnE,IAAID,+BAA+B;YACjC,MAAME,wBAAwBjB,iBAAgD;gBAC5EkB,WAAWhB,KAAKiB,OAAO,CAACD,SAAS;gBACjCE,kBAAkBL;gBAClBM,YAAY;gBACZC,QAAQ;YACV;YAEA,IAAI,CAACL,uBAAuB;gBAC1B;YACF;YAEA,MAAMM,qBACJT,gBAAgBS,kBAAkB,IAAI,CAAC;YACzCA,mBAAmBV,UAAU,GAAGC,gBAAgBU,GAAG;YACnDD,mBAAmBb,KAAK,GAAGI,gBAAgBJ,KAAK;YAChD,IACE,OAAOK,kCAAkC,YACzCA,8BAA8BU,WAAW,EACzC;gBACAF,mBAAmBE,WAAW,GAAGV,8BAA8BU,WAAW;YAC5E;YACA,qKAAqK;YACrKtB,cAAc,CAACU,WAAW,GAAG;gBAAEU;gBAAoBN;YAAsB;QAC3E;QAEA;;KAEC,GACD,uHAAuH;QACvH,4EAA4E;QAC5E,0JAA0J;QAC1J,IAAIH,gBAAgBY,iBAAiB,EAAE;YACrC,MAAMC,oBAAoB,GAAGzB,KAAKmB,UAAU,CAAC,0BAA0B,EAAER,YAAY;YAErFF,sBAAsB,CAACE,WAAW,GAAG,CAAC;YAEtC,0FAA0F;YAC1F,KAAK,MAAM,CAACW,KAAKI,MAAM,IAAI1B,KAAK2B,oBAAoB,CAACC,OAAO,GAAI;gBAC9D,IAAIN,IAAIO,UAAU,CAACJ,oBAAoB;oBACrChB,sBAAsB,CAACE,WAAW,CAACW,IAAI,GAAG,YAAYI,QAAQA,MAAMI,MAAM,GAAG;wBAACJ;qBAAM;gBACtF;YACF;QACF;QAEA,IACEd,gBAAgBmB,gBAAgB,IAChC,OAAOnB,gBAAgBmB,gBAAgB,KAAK,YAC5C,CAACC,MAAMC,OAAO,CAACrB,gBAAgBmB,gBAAgB,GAC/C;YACA,KAAK,MAAM,CAACT,KAAKY,iBAAiB,IAAIC,OAAOP,OAAO,CAAChB,gBAAgBmB,gBAAgB,EAAG;gBACtF,MAAMK,oBAAoBtC,iBAAiB;oBACzCkB,WAAWhB,KAAKiB,OAAO,CAACD,SAAS;oBACjCE,kBAAkBgB;oBAClBf,YAAY;oBACZC,QAAQ;gBACV;gBAEAV,sBAAsB,CAAC,GAAGE,gBAAgBU,GAAG,CAAC,CAAC,EAAEA,KAAK,CAAC,GAAGc;YAC5D;QACF;IACF;IACA,OAAO;QACLnC;QACAS;QACAD;IACF;AACF"}
+{"version":3,"file":"initLexicalFeatures.js","names":["getFromImportMap","initLexicalFeatures","args","clientFeatures","resolvedFeatureMapArray","sanitizedEditorConfig","resolvedFeatureMap","sort","a","b","order","featureClientSchemaMap","featureClientImportMap","featureKey","resolvedFeature","ClientFeaturePayloadComponent","ClientFeature","clientFeatureProvider","importMap","payload","PayloadComponent","schemaPath","silent","clientFeatureProps","key","clientProps","generateSchemaMap","featureSchemaPath","entry","clientFieldSchemaMap","entries","startsWith","fields","componentImports","Array","isArray","payloadComponent","Object","resolvedComponent"],"sources":["../../src/utilities/initLexicalFeatures.ts"],"sourcesContent":["import type { I18nClient } from '@payloadcms/translations'\n\nimport { type ClientFieldSchemaMap, type FieldSchemaMap, type Payload } from 'payload'\nimport { getFromImportMap } from 'payload/shared'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from '../features/typesClient.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js'\ntype Args = {\n  clientFieldSchemaMap: ClientFieldSchemaMap\n  fieldSchemaMap: FieldSchemaMap\n  i18n: I18nClient\n  path: string\n  payload: Payload\n  sanitizedEditorConfig: SanitizedServerEditorConfig\n  schemaPath: string\n}\n\nexport function initLexicalFeatures(args: Args): {\n  clientFeatures: LexicalRichTextFieldProps['clientFeatures']\n  featureClientImportMap: Record<string, any>\n  featureClientSchemaMap: FeatureClientSchemaMap\n} {\n  const clientFeatures: LexicalRichTextFieldProps['clientFeatures'] = {}\n\n  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n  const resolvedFeatureMapArray = [...args.sanitizedEditorConfig.resolvedFeatureMap].sort(\n    (a, b) => a[1].order - b[1].order,\n  )\n\n  const featureClientSchemaMap: FeatureClientSchemaMap = {}\n\n  /**\n   * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used\n   */\n  const featureClientImportMap: Record<string, any> | undefined = {}\n\n  for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray) {\n    clientFeatures[featureKey] = {}\n\n    /**\n     * Handle client features\n     */\n    const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature\n\n    if (ClientFeaturePayloadComponent) {\n      const clientFeatureProvider = getFromImportMap<FeatureProviderProviderClient>({\n        importMap: args.payload.importMap,\n        PayloadComponent: ClientFeaturePayloadComponent,\n        schemaPath: 'lexical-clientComponent',\n        silent: true,\n      })\n\n      if (!clientFeatureProvider) {\n        continue\n      }\n\n      const clientFeatureProps: BaseClientFeatureProps<Record<string, any>> =\n        resolvedFeature.clientFeatureProps ?? {}\n      clientFeatureProps.featureKey = resolvedFeature.key\n      clientFeatureProps.order = resolvedFeature.order\n      if (\n        typeof ClientFeaturePayloadComponent === 'object' &&\n        ClientFeaturePayloadComponent.clientProps\n      ) {\n        clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps\n      }\n      // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props\n      clientFeatures[featureKey] = { clientFeatureProps, clientFeatureProvider }\n    }\n\n    /**\n     * Handle sub-fields (formstate of those)\n     */\n    // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas\n    // as well, as it already called feature.generateSchemaMap for each feature.\n    // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here\n    if (resolvedFeature.generateSchemaMap) {\n      const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`\n\n      featureClientSchemaMap[featureKey] = {}\n\n      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature\n      for (const [key, entry] of args.clientFieldSchemaMap.entries()) {\n        if (key.startsWith(featureSchemaPath)) {\n          featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [entry]\n        }\n      }\n    }\n\n    if (\n      resolvedFeature.componentImports &&\n      typeof resolvedFeature.componentImports === 'object' &&\n      !Array.isArray(resolvedFeature.componentImports)\n    ) {\n      for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)) {\n        const resolvedComponent = getFromImportMap({\n          importMap: args.payload.importMap,\n          PayloadComponent: payloadComponent,\n          schemaPath: 'lexical-clientComponent',\n          silent: true,\n        })\n\n        featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent\n      }\n    }\n  }\n  return {\n    clientFeatures,\n    featureClientImportMap,\n    featureClientSchemaMap,\n  }\n}\n"],"mappings":"AAGA,SAASA,gBAAgB,QAAQ;AAkBjC,OAAO,SAASC,oBAAoBC,IAAU;EAK5C,MAAMC,cAAA,GAA8D,CAAC;EAErE;EACA,MAAMC,uBAAA,GAA0B,C,GAAIF,IAAA,CAAKG,qBAAqB,CAACC,kBAAkB,CAAC,CAACC,IAAI,CACrF,CAACC,CAAA,EAAGC,CAAA,KAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;EAGnC,MAAMC,sBAAA,GAAiD,CAAC;EAExD;;;EAGA,MAAMC,sBAAA,GAA0D,CAAC;EAEjE,KAAK,MAAM,CAACC,UAAA,EAAYC,eAAA,CAAgB,IAAIV,uBAAA,EAAyB;IACnED,cAAc,CAACU,UAAA,CAAW,GAAG,CAAC;IAE9B;;;IAGA,MAAME,6BAAA,GAAgCD,eAAA,CAAgBE,aAAa;IAEnE,IAAID,6BAAA,EAA+B;MACjC,MAAME,qBAAA,GAAwBjB,gBAAA,CAAgD;QAC5EkB,SAAA,EAAWhB,IAAA,CAAKiB,OAAO,CAACD,SAAS;QACjCE,gBAAA,EAAkBL,6BAAA;QAClBM,UAAA,EAAY;QACZC,MAAA,EAAQ;MACV;MAEA,IAAI,CAACL,qBAAA,EAAuB;QAC1B;MACF;MAEA,MAAMM,kBAAA,GACJT,eAAA,CAAgBS,kBAAkB,IAAI,CAAC;MACzCA,kBAAA,CAAmBV,UAAU,GAAGC,eAAA,CAAgBU,GAAG;MACnDD,kBAAA,CAAmBb,KAAK,GAAGI,eAAA,CAAgBJ,KAAK;MAChD,IACE,OAAOK,6BAAA,KAAkC,YACzCA,6BAAA,CAA8BU,WAAW,EACzC;QACAF,kBAAA,CAAmBE,WAAW,GAAGV,6BAAA,CAA8BU,WAAW;MAC5E;MACA;MACAtB,cAAc,CAACU,UAAA,CAAW,GAAG;QAAEU,kBAAA;QAAoBN;MAAsB;IAC3E;IAEA;;MAAA,CAGA;IACA;IACA;IACA,IAAIH,eAAA,CAAgBY,iBAAiB,EAAE;MACrC,MAAMC,iBAAA,GAAoB,GAAGzB,IAAA,CAAKmB,UAAU,6BAA6BR,UAAA,EAAY;MAErFF,sBAAsB,CAACE,UAAA,CAAW,GAAG,CAAC;MAEtC;MACA,KAAK,MAAM,CAACW,GAAA,EAAKI,KAAA,CAAM,IAAI1B,IAAA,CAAK2B,oBAAoB,CAACC,OAAO,IAAI;QAC9D,IAAIN,GAAA,CAAIO,UAAU,CAACJ,iBAAA,GAAoB;UACrChB,sBAAsB,CAACE,UAAA,CAAW,CAACW,GAAA,CAAI,GAAG,YAAYI,KAAA,GAAQA,KAAA,CAAMI,MAAM,GAAG,CAACJ,KAAA,CAAM;QACtF;MACF;IACF;IAEA,IACEd,eAAA,CAAgBmB,gBAAgB,IAChC,OAAOnB,eAAA,CAAgBmB,gBAAgB,KAAK,YAC5C,CAACC,KAAA,CAAMC,OAAO,CAACrB,eAAA,CAAgBmB,gBAAgB,GAC/C;MACA,KAAK,MAAM,CAACT,GAAA,EAAKY,gBAAA,CAAiB,IAAIC,MAAA,CAAOP,OAAO,CAAChB,eAAA,CAAgBmB,gBAAgB,GAAG;QACtF,MAAMK,iBAAA,GAAoBtC,gBAAA,CAAiB;UACzCkB,SAAA,EAAWhB,IAAA,CAAKiB,OAAO,CAACD,SAAS;UACjCE,gBAAA,EAAkBgB,gBAAA;UAClBf,UAAA,EAAY;UACZC,MAAA,EAAQ;QACV;QAEAV,sBAAsB,CAAC,GAAGE,eAAA,CAAgBU,GAAG,IAAIA,GAAA,EAAK,CAAC,GAAGc,iBAAA;MAC5D;IACF;EACF;EACA,OAAO;IACLnC,cAAA;IACAS,sBAAA;IACAD;EACF;AACF","ignoreList":[]}

package/dist/utilities/jsx/collectTopLevelJSXInLines.js

@@ -46,32 +46,35 @@ import { createTagRegexes } from '../../features/blocks/server/markdown/markdown
  * ]
  *
  * You can then map this data to construct the data for this blocks array field.
- */ export function collectTopLevelJSXInLines(lines, jsxToMatch) {
-    const finds = [];
-    const regex = createTagRegexes(jsxToMatch);
-    const linesLength = lines.length;
-    for(let i = 0; i < linesLength; i++){
-        const line = lines[i];
-        const startMatch = line.match(regex.regExpStart);
-        if (!startMatch) {
-            continue;
-        }
-        // Try next transformer
-        const { content, endLineIndex, propsString } = linesFromStartToContentAndPropsString({
-            isEndOptional: false,
-            lines,
-            regexpEndRegex: regex.regExpEnd,
-            startLineIndex: i,
-            startMatch
-        });
-        finds.push({
-            content,
-            propsString
-        });
-        i = endLineIndex;
-        continue;
+ */
+export function collectTopLevelJSXInLines(lines, jsxToMatch) {
+  const finds = [];
+  const regex = createTagRegexes(jsxToMatch);
+  const linesLength = lines.length;
+  for (let i = 0; i < linesLength; i++) {
+    const line = lines[i];
+    const startMatch = line.match(regex.regExpStart);
+    if (!startMatch) {
+      continue; // Try next transformer
     }
-    return finds;
+    const {
+      content,
+      endLineIndex,
+      propsString
+    } = linesFromStartToContentAndPropsString({
+      isEndOptional: false,
+      lines,
+      regexpEndRegex: regex.regExpEnd,
+      startLineIndex: i,
+      startMatch
+    });
+    finds.push({
+      content,
+      propsString
+    });
+    i = endLineIndex;
+    continue;
+  }
+  return finds;
 }
-
 //# sourceMappingURL=collectTopLevelJSXInLines.js.map

package/dist/utilities/jsx/collectTopLevelJSXInLines.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utilities/jsx/collectTopLevelJSXInLines.ts"],"sourcesContent":["import { linesFromStartToContentAndPropsString } from '../../features/blocks/server/markdown/linesFromMatchToContentAndPropsString.js'\nimport { createTagRegexes } from '../../features/blocks/server/markdown/markdownTransformer.js'\n\n/**\n * Helpful utility for parsing out all matching top-level JSX tags in a given string.\n * This will collect them in a list, that contains the content of the JSX tag and the props string.\n *\n * While this is not used within payload, this can be used for certain payload blocks that need to\n * be serializable and deserializable to and from JSX.\n *\n * @example:\n *\n * Say you have Steps block that contains a steps array. Its JSX representation may look like this:\n *\n * <Steps>\n *   <Step title=\"Step1\">\n *     <h1>Step 1</h1>\n *   </Step>\n *   <Step title=\"Step2\">\n *     <h1>Step 2</h1>\n *   </Step>\n * </Steps>\n *\n * In this case, the Steps block would have the following content as its children string:\n * <Step title=\"Step1\">\n *   <h1>Step 1</h1>\n * </Step>\n * <Step title=\"Step2\">\n *   <h1>Step 2</h1>\n * </Step>\n *\n * It could then use this function to collect all the top-level JSX tags (= the steps):\n *\n * collectTopLevelJSXInLines(children.split('\\n'), 'Step')\n *\n * This will return:\n *\n * [\n *   {\n *     content: '<h1>Step 1</h1>',\n *     propsString: 'title=\"Step1\"',\n *   },\n *   {\n *     content: '<h1>Step 2</h1>',\n *     propsString: 'title=\"Step2\"',\n *   },\n * ]\n *\n * You can then map this data to construct the data for this blocks array field.\n */\nexport function collectTopLevelJSXInLines(\n  lines: Array<string>,\n  jsxToMatch: string,\n): {\n  content: string\n  propsString: string\n}[] {\n  const finds: {\n    content: string\n    propsString: string\n  }[] = []\n  const regex = createTagRegexes(jsxToMatch)\n\n  const linesLength = lines.length\n\n  for (let i = 0; i < linesLength; i++) {\n    const line = lines[i]!\n    const startMatch = line.match(regex.regExpStart)\n    if (!startMatch) {\n      continue // Try next transformer\n    }\n\n    const { content, endLineIndex, propsString } = linesFromStartToContentAndPropsString({\n      isEndOptional: false,\n      lines,\n      regexpEndRegex: regex.regExpEnd,\n      startLineIndex: i,\n      startMatch,\n    })\n\n    finds.push({\n      content,\n      propsString,\n    })\n\n    i = endLineIndex\n    continue\n  }\n\n  return finds\n}\n"],"names":["linesFromStartToContentAndPropsString","createTagRegexes","collectTopLevelJSXInLines","lines","jsxToMatch","finds","regex","linesLength","length","i","line","startMatch","match","regExpStart","content","endLineIndex","propsString","isEndOptional","regexpEndRegex","regExpEnd","startLineIndex","push"],"mappings":"AAAA,SAASA,qCAAqC,QAAQ,iFAAgF;AACtI,SAASC,gBAAgB,QAAQ,+DAA8D;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CC,GACD,OAAO,SAASC,0BACdC,KAAoB,EACpBC,UAAkB;IAKlB,MAAMC,QAGA,EAAE;IACR,MAAMC,QAAQL,iBAAiBG;IAE/B,MAAMG,cAAcJ,MAAMK,MAAM;IAEhC,IAAK,IAAIC,IAAI,GAAGA,IAAIF,aAAaE,IAAK;QACpC,MAAMC,OAAOP,KAAK,CAACM,EAAE;QACrB,MAAME,aAAaD,KAAKE,KAAK,CAACN,MAAMO,WAAW;QAC/C,IAAI,CAACF,YAAY;YACf;QACF;QADW,uBAAuB;QAGlC,MAAM,EAAEG,OAAO,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGhB,sCAAsC;YACnFiB,eAAe;YACfd;YACAe,gBAAgBZ,MAAMa,SAAS;YAC/BC,gBAAgBX;YAChBE;QACF;QAEAN,MAAMgB,IAAI,CAAC;YACTP;YACAE;QACF;QAEAP,IAAIM;QACJ;IACF;IAEA,OAAOV;AACT"}
+{"version":3,"file":"collectTopLevelJSXInLines.js","names":["linesFromStartToContentAndPropsString","createTagRegexes","collectTopLevelJSXInLines","lines","jsxToMatch","finds","regex","linesLength","length","i","line","startMatch","match","regExpStart","content","endLineIndex","propsString","isEndOptional","regexpEndRegex","regExpEnd","startLineIndex","push"],"sources":["../../../src/utilities/jsx/collectTopLevelJSXInLines.ts"],"sourcesContent":["import { linesFromStartToContentAndPropsString } from '../../features/blocks/server/markdown/linesFromMatchToContentAndPropsString.js'\nimport { createTagRegexes } from '../../features/blocks/server/markdown/markdownTransformer.js'\n\n/**\n * Helpful utility for parsing out all matching top-level JSX tags in a given string.\n * This will collect them in a list, that contains the content of the JSX tag and the props string.\n *\n * While this is not used within payload, this can be used for certain payload blocks that need to\n * be serializable and deserializable to and from JSX.\n *\n * @example:\n *\n * Say you have Steps block that contains a steps array. Its JSX representation may look like this:\n *\n * <Steps>\n *   <Step title=\"Step1\">\n *     <h1>Step 1</h1>\n *   </Step>\n *   <Step title=\"Step2\">\n *     <h1>Step 2</h1>\n *   </Step>\n * </Steps>\n *\n * In this case, the Steps block would have the following content as its children string:\n * <Step title=\"Step1\">\n *   <h1>Step 1</h1>\n * </Step>\n * <Step title=\"Step2\">\n *   <h1>Step 2</h1>\n * </Step>\n *\n * It could then use this function to collect all the top-level JSX tags (= the steps):\n *\n * collectTopLevelJSXInLines(children.split('\\n'), 'Step')\n *\n * This will return:\n *\n * [\n *   {\n *     content: '<h1>Step 1</h1>',\n *     propsString: 'title=\"Step1\"',\n *   },\n *   {\n *     content: '<h1>Step 2</h1>',\n *     propsString: 'title=\"Step2\"',\n *   },\n * ]\n *\n * You can then map this data to construct the data for this blocks array field.\n */\nexport function collectTopLevelJSXInLines(\n  lines: Array<string>,\n  jsxToMatch: string,\n): {\n  content: string\n  propsString: string\n}[] {\n  const finds: {\n    content: string\n    propsString: string\n  }[] = []\n  const regex = createTagRegexes(jsxToMatch)\n\n  const linesLength = lines.length\n\n  for (let i = 0; i < linesLength; i++) {\n    const line = lines[i]!\n    const startMatch = line.match(regex.regExpStart)\n    if (!startMatch) {\n      continue // Try next transformer\n    }\n\n    const { content, endLineIndex, propsString } = linesFromStartToContentAndPropsString({\n      isEndOptional: false,\n      lines,\n      regexpEndRegex: regex.regExpEnd,\n      startLineIndex: i,\n      startMatch,\n    })\n\n    finds.push({\n      content,\n      propsString,\n    })\n\n    i = endLineIndex\n    continue\n  }\n\n  return finds\n}\n"],"mappings":"AAAA,SAASA,qCAAqC,QAAQ;AACtD,SAASC,gBAAgB,QAAQ;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,OAAO,SAASC,0BACdC,KAAoB,EACpBC,UAAkB;EAKlB,MAAMC,KAAA,GAGA,EAAE;EACR,MAAMC,KAAA,GAAQL,gBAAA,CAAiBG,UAAA;EAE/B,MAAMG,WAAA,GAAcJ,KAAA,CAAMK,MAAM;EAEhC,KAAK,IAAIC,CAAA,GAAI,GAAGA,CAAA,GAAIF,WAAA,EAAaE,CAAA,IAAK;IACpC,MAAMC,IAAA,GAAOP,KAAK,CAACM,CAAA,CAAE;IACrB,MAAME,UAAA,GAAaD,IAAA,CAAKE,KAAK,CAACN,KAAA,CAAMO,WAAW;IAC/C,IAAI,CAACF,UAAA,EAAY;MACf,UAAS;IACX;IAEA,MAAM;MAAEG,OAAO;MAAEC,YAAY;MAAEC;IAAW,CAAE,GAAGhB,qCAAA,CAAsC;MACnFiB,aAAA,EAAe;MACfd,KAAA;MACAe,cAAA,EAAgBZ,KAAA,CAAMa,SAAS;MAC/BC,cAAA,EAAgBX,CAAA;MAChBE;IACF;IAEAN,KAAA,CAAMgB,IAAI,CAAC;MACTP,OAAA;MACAE;IACF;IAEAP,CAAA,GAAIM,YAAA;IACJ;EACF;EAEA,OAAOV,KAAA;AACT","ignoreList":[]}

package/dist/utilities/jsx/declare.d.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utilities/jsx/declare.d.ts"],"names":[],"mappings":""}
+{"version":3,"file":"declare.d.js","names":[],"sources":["../../../src/utilities/jsx/declare.d.ts"],"sourcesContent":[null],"mappings":"","ignoreList":[]}