@payloadcms/richtext-lexical 3.0.0-canary.b8dd0db → 3.0.0-canary.bb00d64

package/dist/index.js

@@ -1,6 +1,4 @@
-import { fileURLToPath } from 'node:url';
-import path from 'path';
-import { afterChangeTraverseFields, afterReadTraverseFields, beforeChangeTraverseFields, beforeValidateTraverseFields, deepCopyObject, deepCopyObjectSimple, getDependencies, withNullableJSONSchemaType } from 'payload';
+import { afterChangeTraverseFields, afterReadTraverseFields, beforeChangeTraverseFields, beforeValidateTraverseFields, checkDependencies, deepCopyObject, deepCopyObjectSimple, withNullableJSONSchemaType } from 'payload';
 import { i18n } from './i18n.js';
 import { defaultEditorConfig, defaultEditorFeatures } from './lexical/config/server/default.js';
 import { loadFeatures } from './lexical/config/server/loader.js';
@@ -11,28 +9,22 @@ import { getGenerateSchemaMap } from './utilities/generateSchemaMap.js';
 import { recurseNodeTree } from './utilities/recurseNodeTree.js';
 import { richTextValidateHOC } from './validate/index.js';
 let defaultSanitizedServerEditorConfig = null;
-const filename = fileURLToPath(import.meta.url);
-const dirname = path.dirname(filename);
+let checkedDependencies = false;
 export function lexicalEditor(props) {
   return async ({
     config,
-    isRoot
+    isRoot,
+    parentIsLocalized
   }) => {
-    if (process.env.NODE_ENV !== 'production' && process.env.PAYLOAD_DISABLE_DEPENDENCY_CHECKER !== 'true') {
-      const resolvedDependencies = await getDependencies(dirname, ['lexical', '@lexical/headless', '@lexical/link', '@lexical/list', '@lexical/mark', '@lexical/markdown', '@lexical/react', '@lexical/rich-text', '@lexical/selection', '@lexical/utils']);
-      // Go through each resolved dependency. If any dependency has a mismatching version, throw an error
-      const foundVersions = {};
-      for (const [_pkg, {
-        version
-      }] of resolvedDependencies.resolved) {
-        if (!Object.keys(foundVersions).includes(version)) {
-          foundVersions[version] = _pkg;
-        }
-      }
-      if (Object.keys(foundVersions).length > 1) {
-        const formattedVersionsWithPackageNameString = Object.entries(foundVersions).map(([version, pkg]) => `${pkg}@${version}`).join(', ');
-        throw new Error(`Mismatching lexical dependency versions found: ${formattedVersionsWithPackageNameString}. All lexical and @lexical/* packages must have the same version. This is an error with your set-up, caused by you, not a bug in payload. Please go to your package.json and ensure all lexical and @lexical/* packages have the same version.`);
-      }
+    if (process.env.NODE_ENV !== 'production' && process.env.PAYLOAD_DISABLE_DEPENDENCY_CHECKER !== 'true' && !checkedDependencies) {
+      checkedDependencies = true;
+      await checkDependencies({
+        dependencyGroups: [{
+          name: 'lexical',
+          dependencies: ['lexical', '@lexical/headless', '@lexical/link', '@lexical/list', '@lexical/mark', '@lexical/markdown', '@lexical/react', '@lexical/rich-text', '@lexical/selection', '@lexical/utils'],
+          targetVersion: '0.18.0'
+        }]
+      });
     }
     let features = [];
     let resolvedFeatureMap;
@@ -40,7 +32,7 @@ export function lexicalEditor(props) {
     ;
     if (!props || !props.features && !props.lexical) {
       if (!defaultSanitizedServerEditorConfig) {
-        defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(defaultEditorConfig, config);
+        defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(defaultEditorConfig, config, parentIsLocalized);
         features = deepCopyObject(defaultEditorFeatures);
       }
       finalSanitizedEditorConfig = deepCopyObject(defaultSanitizedServerEditorConfig);
@@ -62,6 +54,7 @@ export function lexicalEditor(props) {
       resolvedFeatureMap = await loadFeatures({
         config,
         isRoot,
+        parentIsLocalized,
         unSanitizedEditorConfig: {
           features,
           lexical
@@ -84,25 +77,19 @@ export function lexicalEditor(props) {
     }
     return {
       CellComponent: {
-        clientProps: {
-          admin: props?.admin,
-          lexicalEditorConfig: finalSanitizedEditorConfig.lexical
-        },
-        path: '@payloadcms/richtext-lexical/client#RichTextCell'
-      },
-      FieldComponent: {
-        clientProps: {
+        path: '@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell',
+        serverProps: {
           admin: props?.admin,
-          lexicalEditorConfig: finalSanitizedEditorConfig.lexical
-        },
-        path: '@payloadcms/richtext-lexical/client#RichTextField'
+          sanitizedEditorConfig: finalSanitizedEditorConfig
+        }
       },
       editorConfig: finalSanitizedEditorConfig,
       features,
-      generateComponentMap: {
-        path: '@payloadcms/richtext-lexical/generateComponentMap#getGenerateComponentMap',
+      FieldComponent: {
+        path: '@payloadcms/richtext-lexical/rsc#RscEntryLexicalField',
         serverProps: {
-          resolvedFeatureMap
+          admin: props?.admin,
+          sanitizedEditorConfig: finalSanitizedEditorConfig
         }
       },
       generateImportMap: getGenerateImportMap({
@@ -165,7 +152,7 @@ export function lexicalEditor(props) {
               value = await hook(args);
             }
           }
-          if (!finalSanitizedEditorConfig.features.nodeHooks.afterChange.size && !finalSanitizedEditorConfig.features.getSubFields.size) {
+          if (!finalSanitizedEditorConfig.features.nodeHooks?.afterChange?.size && !finalSanitizedEditorConfig.features.getSubFields?.size) {
             return value;
           }
           const context = _context;
@@ -183,9 +170,10 @@ export function lexicalEditor(props) {
           });
           // eslint-disable-next-line prefer-const
           for (let [id, node] of Object.entries(nodeIDMap)) {
-            const afterChangeHooks = finalSanitizedEditorConfig.features.nodeHooks.afterChange;
-            if (afterChangeHooks?.has(node.type)) {
-              for (const hook of afterChangeHooks.get(node.type)) {
+            const afterChangeHooks = finalSanitizedEditorConfig.features.nodeHooks?.afterChange;
+            const afterChangeHooksForNode = afterChangeHooks?.get(node.type);
+            if (afterChangeHooksForNode) {
+              for (const hook of afterChangeHooksForNode) {
                 if (!originalNodeIDMap[id]) {
                   console.warn('(afterChange) No original node found for node with id', id, 'node:', node, 'path', path.join('.'));
                   continue;
@@ -201,9 +189,9 @@ export function lexicalEditor(props) {
                 });
               }
             }
-            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type);
-            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(node.type);
-            if (subFieldFn) {
+            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields?.get(node.type);
+            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData?.get(node.type);
+            if (subFieldFn && subFieldDataFn) {
               const subFields = subFieldFn({
                 node,
                 req
@@ -261,6 +249,7 @@ export function lexicalEditor(props) {
             locale,
             overrideAccess,
             path,
+            populate,
             populationPromises,
             req,
             schemaPath,
@@ -276,7 +265,7 @@ export function lexicalEditor(props) {
               value = await hook(args);
             }
           }
-          if (!finalSanitizedEditorConfig.features.nodeHooks.afterRead.size && !finalSanitizedEditorConfig.features.getSubFields.size) {
+          if (!finalSanitizedEditorConfig.features.nodeHooks?.afterRead?.size && !finalSanitizedEditorConfig.features.getSubFields?.size) {
             return value;
           }
           const flattenedNodes = [];
@@ -285,34 +274,36 @@ export function lexicalEditor(props) {
             nodes: value?.root?.children ?? []
           });
           for (let node of flattenedNodes) {
-            const afterReadHooks = finalSanitizedEditorConfig.features.nodeHooks.afterRead;
-            if (afterReadHooks?.has(node.type)) {
-              for (const hook of afterReadHooks.get(node.type)) {
+            const afterReadHooks = finalSanitizedEditorConfig.features.nodeHooks?.afterRead;
+            const afterReadHooksForNode = afterReadHooks?.get(node.type);
+            if (afterReadHooksForNode) {
+              for (const hook of afterReadHooksForNode) {
                 node = await hook({
                   context,
-                  currentDepth,
-                  depth,
-                  draft,
-                  fallbackLocale,
-                  fieldPromises,
-                  findMany,
-                  flattenLocales,
-                  locale,
+                  currentDepth: currentDepth,
+                  depth: depth,
+                  draft: draft,
+                  fallbackLocale: fallbackLocale,
+                  fieldPromises: fieldPromises,
+                  findMany: findMany,
+                  flattenLocales: flattenLocales,
+                  locale: locale,
                   node,
-                  overrideAccess,
+                  overrideAccess: overrideAccess,
                   parentRichTextFieldPath: path,
                   parentRichTextFieldSchemaPath: schemaPath,
-                  populationPromises,
+                  populateArg: populate,
+                  populationPromises: populationPromises,
                   req,
-                  showHiddenFields,
-                  triggerAccessControl,
-                  triggerHooks
+                  showHiddenFields: showHiddenFields,
+                  triggerAccessControl: triggerAccessControl,
+                  triggerHooks: triggerHooks
                 });
               }
             }
-            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type);
-            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(node.type);
-            if (subFieldFn) {
+            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields?.get(node.type);
+            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData?.get(node.type);
+            if (subFieldFn && subFieldDataFn) {
               const subFields = subFieldFn({
                 node,
                 req
@@ -325,23 +316,24 @@ export function lexicalEditor(props) {
                 afterReadTraverseFields({
                   collection,
                   context,
-                  currentDepth,
-                  depth,
+                  currentDepth: currentDepth,
+                  depth: depth,
                   doc: data,
-                  draft,
-                  fallbackLocale,
-                  fieldPromises,
+                  draft: draft,
+                  fallbackLocale: fallbackLocale,
+                  fieldPromises: fieldPromises,
                   fields: subFields,
-                  findMany,
-                  flattenLocales,
+                  findMany: findMany,
+                  flattenLocales: flattenLocales,
                   global,
-                  locale,
-                  overrideAccess,
+                  locale: locale,
+                  overrideAccess: overrideAccess,
                   path,
-                  populationPromises,
+                  populate,
+                  populationPromises: populationPromises,
                   req,
                   schemaPath,
-                  showHiddenFields,
+                  showHiddenFields: showHiddenFields,
                   siblingDoc: data,
                   triggerAccessControl,
                   triggerHooks
@@ -355,7 +347,6 @@ export function lexicalEditor(props) {
           const {
             collection,
             context: _context,
-            duplicate,
             errors,
             field,
             global,
@@ -376,7 +367,7 @@ export function lexicalEditor(props) {
               value = await hook(args);
             }
           }
-          if (!finalSanitizedEditorConfig.features.nodeHooks.beforeChange.size && !finalSanitizedEditorConfig.features.getSubFields.size) {
+          if (!finalSanitizedEditorConfig.features.nodeHooks?.beforeChange?.size && !finalSanitizedEditorConfig.features.getSubFields?.size) {
             return value;
           }
           const context = _context;
@@ -393,7 +384,7 @@ export function lexicalEditor(props) {
             nodeIDMap,
             nodes: value?.root?.children ?? []
           });
-          if (siblingDocWithLocales?.[field.name]) {
+          if (field.name && siblingDocWithLocales?.[field.name]) {
             recurseNodeTree({
               nodeIDMap: originalNodeWithLocalesIDMap,
               nodes: siblingDocWithLocales[field.name]?.root?.children ?? []
@@ -401,32 +392,32 @@ export function lexicalEditor(props) {
           }
           // eslint-disable-next-line prefer-const
           for (let [id, node] of Object.entries(nodeIDMap)) {
-            const beforeChangeHooks = finalSanitizedEditorConfig.features.nodeHooks.beforeChange;
-            if (beforeChangeHooks?.has(node.type)) {
-              for (const hook of beforeChangeHooks.get(node.type)) {
+            const beforeChangeHooks = finalSanitizedEditorConfig.features.nodeHooks?.beforeChange;
+            const beforeChangeHooksForNode = beforeChangeHooks?.get(node.type);
+            if (beforeChangeHooksForNode) {
+              for (const hook of beforeChangeHooksForNode) {
                 if (!originalNodeIDMap[id]) {
                   console.warn('(beforeChange) No original node found for node with id', id, 'node:', node, 'path', path.join('.'));
                   continue;
                 }
                 node = await hook({
                   context,
-                  duplicate,
-                  errors,
-                  mergeLocaleActions,
+                  errors: errors,
+                  mergeLocaleActions: mergeLocaleActions,
                   node,
-                  operation,
+                  operation: operation,
                   originalNode: originalNodeIDMap[id],
                   originalNodeWithLocales: originalNodeWithLocalesIDMap[id],
                   parentRichTextFieldPath: path,
                   parentRichTextFieldSchemaPath: schemaPath,
                   req,
-                  skipValidation
+                  skipValidation: skipValidation
                 });
               }
             }
-            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type);
-            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(node.type);
-            if (subFieldFn) {
+            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields?.get(node.type);
+            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData?.get(node.type);
+            if (subFieldFn && subFieldDataFn) {
               const subFields = subFieldFn({
                 node,
                 req
@@ -451,12 +442,11 @@ export function lexicalEditor(props) {
                   data,
                   doc: originalData,
                   docWithLocales: originalDataWithLocales ?? {},
-                  duplicate,
-                  errors,
+                  errors: errors,
                   fields: subFields,
                   global,
-                  mergeLocaleActions,
-                  operation,
+                  mergeLocaleActions: mergeLocaleActions,
+                  operation: operation,
                   path,
                   req,
                   schemaPath,
@@ -517,7 +507,7 @@ export function lexicalEditor(props) {
             }
           }
           // return value if there are NO hooks
-          if (!finalSanitizedEditorConfig.features.nodeHooks.beforeValidate.size && !finalSanitizedEditorConfig.features.nodeHooks.afterChange.size && !finalSanitizedEditorConfig.features.nodeHooks.beforeChange.size && !finalSanitizedEditorConfig.features.getSubFields.size) {
+          if (!finalSanitizedEditorConfig.features.nodeHooks?.beforeValidate?.size && !finalSanitizedEditorConfig.features.nodeHooks?.afterChange?.size && !finalSanitizedEditorConfig.features.nodeHooks?.beforeChange?.size && !finalSanitizedEditorConfig.features.getSubFields?.size) {
             return value;
           }
           /**
@@ -536,7 +526,6 @@ export function lexicalEditor(props) {
           * - afterChange
           * - beforeChange
           * - beforeValidate
-          * - beforeDuplicate
           *
           * Other hooks are handled by the flattenedNodes. All nodes in the nodeIDMap are part of flattenedNodes.
           */
@@ -558,7 +547,7 @@ export function lexicalEditor(props) {
           /**
           * Now that the maps for all hooks are set up, we can run the validate hook
           */
-          if (!finalSanitizedEditorConfig.features.nodeHooks.beforeValidate.size) {
+          if (!finalSanitizedEditorConfig.features.nodeHooks?.beforeValidate?.size) {
             return value;
           }
           const nodeIDMap = {};
@@ -570,8 +559,9 @@ export function lexicalEditor(props) {
           // eslint-disable-next-line prefer-const
           for (let [id, node] of Object.entries(nodeIDMap)) {
             const beforeValidateHooks = finalSanitizedEditorConfig.features.nodeHooks.beforeValidate;
-            if (beforeValidateHooks?.has(node.type)) {
-              for (const hook of beforeValidateHooks.get(node.type)) {
+            const beforeValidateHooksForNode = beforeValidateHooks?.get(node.type);
+            if (beforeValidateHooksForNode) {
+              for (const hook of beforeValidateHooksForNode) {
                 if (!originalNodeIDMap[id]) {
                   console.warn('(beforeValidate) No original node found for node with id', id, 'node:', node, 'path', path.join('.'));
                   continue;
@@ -581,16 +571,16 @@ export function lexicalEditor(props) {
                   node,
                   operation,
                   originalNode: originalNodeIDMap[id],
-                  overrideAccess,
+                  overrideAccess: overrideAccess,
                   parentRichTextFieldPath: path,
                   parentRichTextFieldSchemaPath: schemaPath,
                   req
                 });
               }
             }
-            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type);
-            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(node.type);
-            if (subFieldFn) {
+            const subFieldFn = finalSanitizedEditorConfig.features.getSubFields?.get(node.type);
+            const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData?.get(node.type);
+            if (subFieldFn && subFieldDataFn) {
               const subFields = subFieldFn({
                 node,
                 req
@@ -613,7 +603,7 @@ export function lexicalEditor(props) {
                   fields: subFields,
                   global,
                   operation,
-                  overrideAccess,
+                  overrideAccess: overrideAccess,
                   path,
                   req,
                   schemaPath,
@@ -746,9 +736,10 @@ export { defaultEditorConfig, defaultEditorFeatures, defaultEditorLexicalConfig
 export { loadFeatures, sortFeaturesForOptimalLoading } from './lexical/config/server/loader.js';
 export { sanitizeServerEditorConfig, sanitizeServerFeatures } from './lexical/config/server/sanitize.js';
 export { getEnabledNodes } from './lexical/nodes/index.js';
-export { DETAIL_TYPE_TO_DETAIL, DOUBLE_LINE_BREAK, ELEMENT_FORMAT_TO_TYPE, ELEMENT_TYPE_TO_FORMAT, IS_ALL_FORMATTING, LTR_REGEX, NON_BREAKING_SPACE, NodeFormat, RTL_REGEX, TEXT_MODE_TO_TYPE, TEXT_TYPE_TO_FORMAT, TEXT_TYPE_TO_MODE } from './lexical/utils/nodeFormat.js';
+export { DETAIL_TYPE_TO_DETAIL, DOUBLE_LINE_BREAK, ELEMENT_FORMAT_TO_TYPE, ELEMENT_TYPE_TO_FORMAT, IS_ALL_FORMATTING, LTR_REGEX, NodeFormat, NON_BREAKING_SPACE, RTL_REGEX, TEXT_MODE_TO_TYPE, TEXT_TYPE_TO_FORMAT, TEXT_TYPE_TO_MODE } from './lexical/utils/nodeFormat.js';
 export { sanitizeUrl, validateUrl } from './lexical/utils/url.js';
 export { defaultRichTextValue } from './populateGraphQL/defaultValue.js';
+export { populate } from './populateGraphQL/populate.js';
 export { createServerFeature } from './utilities/createServerFeature.js';
 export { upgradeLexicalData } from './utilities/upgradeLexicalData/index.js';
 //# sourceMappingURL=index.js.map