@payloadcms/richtext-lexical 3.0.0-beta.4 → 3.0.0-beta.41

package/dist/index.js

@@ -2,201 +2,309 @@ import { withMergedProps } from '@payloadcms/ui/elements/withMergedProps';
 import { withNullableJSONSchemaType } from 'payload/utilities';
 import { RichTextCell } from './cell/index.js';
 import { RichTextField } from './field/index.js';
-import { defaultEditorConfig, defaultEditorFeatures, defaultSanitizedServerEditorConfig } from './field/lexical/config/server/default.js';
+import { defaultEditorConfig, defaultEditorFeatures } from './field/lexical/config/server/default.js';
 import { loadFeatures } from './field/lexical/config/server/loader.js';
-import { sanitizeServerFeatures } from './field/lexical/config/server/sanitize.js';
+import { sanitizeServerEditorConfig, sanitizeServerFeatures } from './field/lexical/config/server/sanitize.js';
 import { cloneDeep } from './field/lexical/utils/cloneDeep.js';
 import { getGenerateComponentMap } from './generateComponentMap.js';
 import { getGenerateSchemaMap } from './generateSchemaMap.js';
-import { richTextRelationshipPromise } from './populate/richTextRelationshipPromise.js';
+import { i18n } from './i18n.js';
+import { populateLexicalPopulationPromises } from './populate/populateLexicalPopulationPromises.js';
 import { richTextValidateHOC } from './validate/index.js';
+let defaultSanitizedServerEditorConfig = null;
 export function lexicalEditor(props) {
-    let resolvedFeatureMap = null;
-    let finalSanitizedEditorConfig// For server only
-    ;
-    if (!props || !props.features && !props.lexical) {
-        finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig);
-        resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap;
-    } else {
-        let features = props.features && typeof props.features === 'function' ? props.features({
-            defaultFeatures: cloneDeep(defaultEditorFeatures)
-        }) : props.features;
-        if (!features) {
-            features = cloneDeep(defaultEditorFeatures);
-        }
-        const lexical = props.lexical;
-        resolvedFeatureMap = loadFeatures({
-            unSanitizedEditorConfig: {
-                features,
-                lexical: lexical ? lexical : defaultEditorConfig.lexical
+    return async ({ config, isRoot })=>{
+        let features = [];
+        let resolvedFeatureMap;
+        let finalSanitizedEditorConfig// For server only
+        ;
+        if (!props || !props.features && !props.lexical) {
+            if (!defaultSanitizedServerEditorConfig) {
+                defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(defaultEditorConfig, config);
+                features = cloneDeep(defaultEditorFeatures);
             }
-        });
-        finalSanitizedEditorConfig = {
-            features: sanitizeServerFeatures(resolvedFeatureMap),
-            lexical: lexical ? lexical : defaultEditorConfig.lexical,
-            resolvedFeatureMap
-        };
-    }
-    return {
-        CellComponent: withMergedProps({
-            Component: RichTextCell,
-            toMergeIntoProps: {
-                lexicalEditorConfig: finalSanitizedEditorConfig.lexical
+            finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig);
+            resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap;
+        } else {
+            const rootEditor = config.editor;
+            let rootEditorFeatures = [];
+            if (typeof rootEditor === 'object' && 'features' in rootEditor) {
+                rootEditorFeatures = rootEditor.features;
             }
-        }),
-        FieldComponent: withMergedProps({
-            Component: RichTextField,
-            toMergeIntoProps: {
-                lexicalEditorConfig: finalSanitizedEditorConfig.lexical
+            features = props.features && typeof props.features === 'function' ? props.features({
+                defaultFeatures: cloneDeep(defaultEditorFeatures),
+                rootFeatures: rootEditorFeatures
+            }) : props.features;
+            if (!features) {
+                features = cloneDeep(defaultEditorFeatures);
             }
-        }),
-        afterReadPromise: ({ field, incomingEditorState, siblingDoc })=>{
-            return new Promise((resolve, reject)=>{
-                const promises = [];
-                if (finalSanitizedEditorConfig?.features?.hooks?.afterReadPromises?.length) {
-                    for (const afterReadPromise of finalSanitizedEditorConfig.features.hooks.afterReadPromises){
-                        const promise = afterReadPromise({
-                            field,
-                            incomingEditorState,
-                            siblingDoc
-                        });
-                        if (promise) {
-                            promises.push(promise);
-                        }
-                    }
+            const lexical = props.lexical;
+            resolvedFeatureMap = await loadFeatures({
+                config,
+                isRoot,
+                unSanitizedEditorConfig: {
+                    features,
+                    lexical: lexical ? lexical : defaultEditorConfig.lexical
                 }
-                Promise.all(promises).then(()=>resolve()).catch((error)=>reject(error));
             });
+            finalSanitizedEditorConfig = {
+                features: sanitizeServerFeatures(resolvedFeatureMap),
+                lexical: lexical ? lexical : defaultEditorConfig.lexical,
+                resolvedFeatureMap
+            };
+        }
+        const featureI18n = finalSanitizedEditorConfig.features.i18n;
+        for(const lang in i18n){
+            if (!featureI18n[lang]) {
+                featureI18n[lang] = {
+                    lexical: {}
+                };
+            }
+            featureI18n[lang].lexical.general = i18n[lang];
+        }
+        return {
+            CellComponent: withMergedProps({
+                Component: RichTextCell,
+                toMergeIntoProps: {
+                    admin: props?.admin,
+                    lexicalEditorConfig: finalSanitizedEditorConfig.lexical
+                }
+            }),
+            FieldComponent: withMergedProps({
+                Component: RichTextField,
+                toMergeIntoProps: {
+                    admin: props?.admin,
+                    lexicalEditorConfig: finalSanitizedEditorConfig.lexical
+                }
+            }),
+            editorConfig: finalSanitizedEditorConfig,
+            features,
+            generateComponentMap: getGenerateComponentMap({
+                resolvedFeatureMap
+            }),
+            generateSchemaMap: getGenerateSchemaMap({
+                resolvedFeatureMap
+            }),
+            i18n: featureI18n,
+            /* hooks: {
+        afterChange: finalSanitizedEditorConfig.features.hooks.afterChange,
+        afterRead: finalSanitizedEditorConfig.features.hooks.afterRead,
+        beforeChange: finalSanitizedEditorConfig.features.hooks.beforeChange,
+        beforeDuplicate: finalSanitizedEditorConfig.features.hooks.beforeDuplicate,
+        beforeValidate: finalSanitizedEditorConfig.features.hooks.beforeValidate,
+      },*/ /* // TODO: Figure out docWithLocales / originalSiblingDoc => node matching. Can't use indexes, as the order of nodes could technically change between hooks.
+      hooks: {
+        afterChange: [
+          async ({ context, findMany, operation, overrideAccess, req, value }) => {
+            await recurseNodesAsync({
+              callback: async (node) => {
+                const afterChangeHooks = finalSanitizedEditorConfig.features.hooks.afterChange
+                if (afterChangeHooks?.has(node.type)) {
+                  for (const hook of afterChangeHooks.get(node.type)) {
+                    node = await hook({ context, findMany, node, operation, overrideAccess, req })
+                  }
+                }
+              },
+              nodes: (value as SerializedEditorState)?.root?.children ?? [],
+            })
+
+            return value
+          },
+        ],
+        afterRead: [
+          async ({ context, findMany, operation, overrideAccess, req, value }) => {
+            await recurseNodesAsync({
+              callback: async (node) => {
+                const afterReadHooks = finalSanitizedEditorConfig.features.hooks.afterRead
+                if (afterReadHooks?.has(node.type)) {
+                  for (const hook of afterReadHooks.get(node.type)) {
+                    node = await hook({ context, findMany, node, operation, overrideAccess, req })
+                  }
+                }
+              },
+              nodes: (value as SerializedEditorState)?.root?.children ?? [],
+            })
+
+            return value
+          },
+        ],
+        beforeChange: [
+          async ({ context, findMany, operation, overrideAccess, req, value }) => {
+            await recurseNodesAsync({
+              callback: async (node) => {
+                const beforeChangeHooks = finalSanitizedEditorConfig.features.hooks.beforeChange
+                if (beforeChangeHooks?.has(node.type)) {
+                  for (const hook of beforeChangeHooks.get(node.type)) {
+                    node = await hook({ context, findMany, node, operation, overrideAccess, req })
+                  }
+                }
+              },
+              nodes: (value as SerializedEditorState)?.root?.children ?? [],
+            })
+
+            return value
+          },
+        ],
+        beforeDuplicate: [
+          async ({ context, findMany, operation, overrideAccess, req, value }) => {
+            await recurseNodesAsync({
+              callback: async (node) => {
+                const beforeDuplicateHooks = finalSanitizedEditorConfig.features.hooks.beforeDuplicate
+                if (beforeDuplicateHooks?.has(node.type)) {
+                  for (const hook of beforeDuplicateHooks.get(node.type)) {
+                    node = await hook({ context, findMany, node, operation, overrideAccess, req })
+                  }
+                }
+              },
+              nodes: (value as SerializedEditorState)?.root?.children ?? [],
+            })
+
+            return value
+          },
+        ],
+        beforeValidate: [
+          async ({ context, findMany, operation, overrideAccess, req, value }) => {
+            await recurseNodesAsync({
+              callback: async (node) => {
+                const beforeValidateHooks = finalSanitizedEditorConfig.features.hooks.beforeValidate
+                if (beforeValidateHooks?.has(node.type)) {
+                  for (const hook of beforeValidateHooks.get(node.type)) {
+                    /**
+                     * We cannot pass the originalNode here, as there is no way to map one node to a previous one, as a previous originalNode might be in a different position
+                     */ /*
+                  node = await hook({ context, findMany, node, operation, overrideAccess, req })
+                }
+              }
+            },
+            nodes: (value as SerializedEditorState)?.root?.children ?? [],
+          })
+
+          return value
         },
-        editorConfig: finalSanitizedEditorConfig,
-        generateComponentMap: getGenerateComponentMap({
-            resolvedFeatureMap
-        }),
-        generateSchemaMap: getGenerateSchemaMap({
-            resolvedFeatureMap
-        }),
-        outputSchema: ({ collectionIDFieldTypes, config, field, interfaceNameDefinitions, isRequired })=>{
-            let outputSchema = {
-                // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.
-                // In the future, we should
-                // 1) allow recursive children
-                // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.
-                type: withNullableJSONSchemaType('object', isRequired),
-                properties: {
-                    root: {
-                        type: 'object',
-                        additionalProperties: false,
-                        properties: {
-                            type: {
-                                type: 'string'
-                            },
-                            children: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    additionalProperties: true,
-                                    properties: {
-                                        type: {
-                                            type: 'string'
+      ],
+    },*/ outputSchema: ({ collectionIDFieldTypes, config, field, interfaceNameDefinitions, isRequired })=>{
+                let outputSchema = {
+                    // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.
+                    // In the future, we should
+                    // 1) allow recursive children
+                    // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.
+                    type: withNullableJSONSchemaType('object', isRequired),
+                    properties: {
+                        root: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                type: {
+                                    type: 'string'
+                                },
+                                children: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        additionalProperties: true,
+                                        properties: {
+                                            type: {
+                                                type: 'string'
+                                            },
+                                            version: {
+                                                type: 'integer'
+                                            }
                                         },
-                                        version: {
-                                            type: 'integer'
+                                        required: [
+                                            'type',
+                                            'version'
+                                        ]
+                                    }
+                                },
+                                direction: {
+                                    oneOf: [
+                                        {
+                                            enum: [
+                                                'ltr',
+                                                'rtl'
+                                            ]
+                                        },
+                                        {
+                                            type: 'null'
                                         }
-                                    },
-                                    required: [
-                                        'type',
-                                        'version'
                                     ]
+                                },
+                                format: {
+                                    type: 'string',
+                                    enum: [
+                                        'left',
+                                        'start',
+                                        'center',
+                                        'right',
+                                        'end',
+                                        'justify',
+                                        ''
+                                    ]
+                                },
+                                indent: {
+                                    type: 'integer'
+                                },
+                                version: {
+                                    type: 'integer'
                                 }
                             },
-                            direction: {
-                                oneOf: [
-                                    {
-                                        enum: [
-                                            'ltr',
-                                            'rtl'
-                                        ]
-                                    },
-                                    {
-                                        type: 'null'
-                                    }
-                                ]
-                            },
-                            format: {
-                                type: 'string',
-                                enum: [
-                                    'left',
-                                    'start',
-                                    'center',
-                                    'right',
-                                    'end',
-                                    'justify',
-                                    ''
-                                ]
-                            },
-                            indent: {
-                                type: 'integer'
-                            },
-                            version: {
-                                type: 'integer'
-                            }
-                        },
-                        required: [
-                            'children',
-                            'direction',
-                            'format',
-                            'indent',
-                            'type',
-                            'version'
-                        ]
-                    }
-                },
-                required: [
-                    'root'
-                ]
-            };
-            for (const modifyOutputSchema of finalSanitizedEditorConfig.features.generatedTypes.modifyOutputSchemas){
-                outputSchema = modifyOutputSchema({
-                    collectionIDFieldTypes,
-                    config,
-                    currentSchema: outputSchema,
-                    field,
-                    interfaceNameDefinitions,
-                    isRequired
-                });
-            }
-            return outputSchema;
-        },
-        populationPromise ({ context, currentDepth, depth, field, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc }) {
-            // check if there are any features with nodes which have populationPromises for this field
-            if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {
-                return richTextRelationshipPromise({
-                    context,
-                    currentDepth,
-                    depth,
-                    editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,
-                    field,
-                    findMany,
-                    flattenLocales,
-                    overrideAccess,
-                    populationPromises,
-                    req,
-                    showHiddenFields,
-                    siblingDoc
-                });
-            }
-            return null;
-        },
-        validate: richTextValidateHOC({
-            editorConfig: finalSanitizedEditorConfig
-        })
+                            required: [
+                                'children',
+                                'direction',
+                                'format',
+                                'indent',
+                                'type',
+                                'version'
+                            ]
+                        }
+                    },
+                    required: [
+                        'root'
+                    ]
+                };
+                for (const modifyOutputSchema of finalSanitizedEditorConfig.features.generatedTypes.modifyOutputSchemas){
+                    outputSchema = modifyOutputSchema({
+                        collectionIDFieldTypes,
+                        config,
+                        currentSchema: outputSchema,
+                        field,
+                        interfaceNameDefinitions,
+                        isRequired
+                    });
+                }
+                return outputSchema;
+            },
+            populationPromises ({ context, currentDepth, depth, draft, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc }) {
+                // check if there are any features with nodes which have populationPromises for this field
+                if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {
+                    populateLexicalPopulationPromises({
+                        context,
+                        currentDepth,
+                        depth,
+                        draft,
+                        editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,
+                        field,
+                        fieldPromises,
+                        findMany,
+                        flattenLocales,
+                        overrideAccess,
+                        populationPromises,
+                        req,
+                        showHiddenFields,
+                        siblingDoc
+                    });
+                }
+            },
+            validate: richTextValidateHOC({
+                editorConfig: finalSanitizedEditorConfig
+            })
+        };
     };
 }
 export { AlignFeature } from './field/features/align/feature.server.js';
-export { BlockQuoteFeature } from './field/features/blockquote/feature.server.js';
+export { BlockquoteFeature } from './field/features/blockquote/feature.server.js';
 export { BlocksFeature } from './field/features/blocks/feature.server.js';
 export { $createBlockNode, $isBlockNode, BlockNode } from './field/features/blocks/nodes/BlocksNode.js';
-export { TextDropdownSectionWithEntries } from './field/features/common/floatingSelectToolbarTextDropdownSection/index.js';
 export { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js';
 export { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js';
 export { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js';
@@ -204,25 +312,25 @@ export { defaultHTMLConverters } from './field/features/converters/html/converte
 export { convertLexicalNodesToHTML, convertLexicalToHTML } from './field/features/converters/html/converter/index.js';
 export { HTMLConverterFeature } from './field/features/converters/html/feature.server.js';
 export { consolidateHTMLConverters, lexicalHTML } from './field/features/converters/html/field/index.js';
-export { createClientComponent } from './field/features/createClientComponent.js';
-export { TestRecorderFeature } from './field/features/debug/testrecorder/feature.server.js';
-export { TreeViewFeature } from './field/features/debug/treeview/feature.server.js';
+export { TestRecorderFeature } from './field/features/debug/testRecorder/feature.server.js';
+export { TreeViewFeature } from './field/features/debug/treeView/feature.server.js';
 export { BoldFeature } from './field/features/format/bold/feature.server.js';
-export { SectionWithEntries as FormatSectionWithEntries } from './field/features/format/common/floatingSelectToolbarSection.js';
-export { InlineCodeFeature } from './field/features/format/inlinecode/feature.server.js';
+export { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js';
 export { ItalicFeature } from './field/features/format/italic/feature.server.js';
+export { toolbarFormatGroupWithItems } from './field/features/format/shared/toolbarFormatGroup.js';
 export { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js';
 export { SubscriptFeature } from './field/features/format/subscript/feature.server.js';
 export { SuperscriptFeature } from './field/features/format/superscript/feature.server.js';
 export { UnderlineFeature } from './field/features/format/underline/feature.server.js';
 export { HeadingFeature } from './field/features/heading/feature.server.js';
+export { HorizontalRuleFeature } from './field/features/horizontalRule/feature.server.js';
 export { IndentFeature } from './field/features/indent/feature.server.js';
 export { LinkFeature } from './field/features/link/feature.server.js';
 export { $createAutoLinkNode, $isAutoLinkNode, AutoLinkNode } from './field/features/link/nodes/AutoLinkNode.js';
 export { $createLinkNode, $isLinkNode, LinkNode, TOGGLE_LINK_COMMAND } from './field/features/link/nodes/LinkNode.js';
-export { CheckListFeature } from './field/features/lists/checklist/feature.server.js';
-export { OrderedListFeature } from './field/features/lists/orderedlist/feature.server.js';
-export { UnorderedListFeature } from './field/features/lists/unorderedlist/feature.server.js';
+export { ChecklistFeature } from './field/features/lists/checklist/feature.server.js';
+export { OrderedListFeature } from './field/features/lists/orderedList/feature.server.js';
+export { UnorderedListFeature } from './field/features/lists/unorderedList/feature.server.js';
 export { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js';
 export { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js';
 export { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js';
@@ -240,16 +348,21 @@ export { SlateToLexicalFeature } from './field/features/migrations/slateToLexica
 export { ParagraphFeature } from './field/features/paragraph/feature.server.js';
 export { RelationshipFeature } from './field/features/relationship/feature.server.js';
 export { $createRelationshipNode, $isRelationshipNode, RelationshipNode } from './field/features/relationship/nodes/RelationshipNode.js';
+export { toolbarAddDropdownGroupWithItems } from './field/features/shared/toolbar/addDropdownGroup.js';
+export { toolbarFeatureButtonsGroupWithItems } from './field/features/shared/toolbar/featureButtonsGroup.js';
+export { toolbarTextDropdownGroupWithItems } from './field/features/shared/toolbar/textDropdownGroup.js';
+export { FixedToolbarFeature } from './field/features/toolbars/fixed/feature.server.js';
+export { InlineToolbarFeature } from './field/features/toolbars/inline/feature.server.js';
+export { createNode } from './field/features/typeUtilities.js';
 export { UploadFeature } from './field/features/upload/feature.server.js';
 export { $createUploadNode, $isUploadNode, UploadNode } from './field/features/upload/nodes/UploadNode.js';
 export { EditorConfigProvider, useEditorConfigContext } from './field/lexical/config/client/EditorConfigProvider.js';
 export { sanitizeClientEditorConfig, sanitizeClientFeatures } from './field/lexical/config/client/sanitize.js';
-export { defaultEditorConfig, defaultEditorFeatures, defaultEditorLexicalConfig, defaultSanitizedServerEditorConfig } from './field/lexical/config/server/default.js';
+export { defaultEditorConfig, defaultEditorFeatures, defaultEditorLexicalConfig } from './field/lexical/config/server/default.js';
 export { loadFeatures, sortFeaturesForOptimalLoading } from './field/lexical/config/server/loader.js';
 export { sanitizeServerEditorConfig, sanitizeServerFeatures } from './field/lexical/config/server/sanitize.js';
 export { getEnabledNodes } from './field/lexical/nodes/index.js';
 export { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js';
-export { SlashMenuGroup, SlashMenuOption } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
 export { CAN_USE_DOM } from './field/lexical/utils/canUseDOM.js';
 export { cloneDeep } from './field/lexical/utils/cloneDeep.js';
 export { getDOMRangeRect } from './field/lexical/utils/getDOMRangeRect.js';