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

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport { withMergedProps } from '@payloadcms/ui/elements/withMergedProps'\nimport { withNullableJSONSchemaType } from 'payload/utilities'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from './field/features/types.js'\nimport type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'\nimport type { AdapterProps, LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n\nimport { RichTextCell } from './cell/index.js'\nimport { RichTextField } from './field/index.js'\nimport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultSanitizedServerEditorConfig,\n} from './field/lexical/config/server/default.js'\nimport { loadFeatures } from './field/lexical/config/server/loader.js'\nimport { sanitizeServerFeatures } from './field/lexical/config/server/sanitize.js'\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nimport { getGenerateComponentMap } from './generateComponentMap.js'\nimport { getGenerateSchemaMap } from './generateSchemaMap.js'\nimport { richTextRelationshipPromise } from './populate/richTextRelationshipPromise.js'\nimport { richTextValidateHOC } from './validate/index.js'\n\nexport function lexicalEditor(props?: LexicalEditorProps): LexicalRichTextAdapter {\n  let resolvedFeatureMap: ResolvedServerFeatureMap = null\n\n  let finalSanitizedEditorConfig: SanitizedServerEditorConfig // For server only\n  if (!props || (!props.features && !props.lexical)) {\n    finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)\n    resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap\n  } else {\n    let features: FeatureProviderServer<unknown, unknown>[] =\n      props.features && typeof props.features === 'function'\n        ? props.features({ defaultFeatures: cloneDeep(defaultEditorFeatures) })\n        : (props.features as FeatureProviderServer<unknown, unknown>[])\n    if (!features) {\n      features = cloneDeep(defaultEditorFeatures)\n    }\n\n    const lexical: LexicalEditorConfig = props.lexical\n\n    resolvedFeatureMap = loadFeatures({\n      unSanitizedEditorConfig: {\n        features,\n        lexical: lexical ? lexical : defaultEditorConfig.lexical,\n      },\n    })\n\n    finalSanitizedEditorConfig = {\n      features: sanitizeServerFeatures(resolvedFeatureMap),\n      lexical: lexical ? lexical : defaultEditorConfig.lexical,\n      resolvedFeatureMap,\n    }\n  }\n\n  return {\n    CellComponent: withMergedProps({\n      Component: RichTextCell,\n      toMergeIntoProps: { lexicalEditorConfig: finalSanitizedEditorConfig.lexical },\n    }),\n    FieldComponent: withMergedProps({\n      Component: RichTextField,\n      toMergeIntoProps: { lexicalEditorConfig: finalSanitizedEditorConfig.lexical },\n    }),\n    afterReadPromise: ({ field, incomingEditorState, siblingDoc }) => {\n      return new Promise<void>((resolve, reject) => {\n        const promises: Promise<void>[] = []\n\n        if (finalSanitizedEditorConfig?.features?.hooks?.afterReadPromises?.length) {\n          for (const afterReadPromise of finalSanitizedEditorConfig.features.hooks\n            .afterReadPromises) {\n            const promise = afterReadPromise({\n              field,\n              incomingEditorState,\n              siblingDoc,\n            })\n            if (promise) {\n              promises.push(promise)\n            }\n          }\n        }\n\n        Promise.all(promises)\n          .then(() => resolve())\n          .catch((error) => reject(error))\n      })\n    },\n    editorConfig: finalSanitizedEditorConfig,\n    generateComponentMap: getGenerateComponentMap({\n      resolvedFeatureMap,\n    }),\n    generateSchemaMap: getGenerateSchemaMap({\n      resolvedFeatureMap,\n    }),\n    outputSchema: ({\n      collectionIDFieldTypes,\n      config,\n      field,\n      interfaceNameDefinitions,\n      isRequired,\n    }) => {\n      let outputSchema: JSONSchema4 = {\n        // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.\n        // In the future, we should\n        // 1) allow recursive children\n        // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.\n        type: withNullableJSONSchemaType('object', isRequired),\n        properties: {\n          root: {\n            type: 'object',\n            additionalProperties: false,\n            properties: {\n              type: {\n                type: 'string',\n              },\n              children: {\n                type: 'array',\n                items: {\n                  type: 'object',\n                  additionalProperties: true,\n                  properties: {\n                    type: {\n                      type: 'string',\n                    },\n                    version: {\n                      type: 'integer',\n                    },\n                  },\n                  required: ['type', 'version'],\n                },\n              },\n              direction: {\n                oneOf: [\n                  {\n                    enum: ['ltr', 'rtl'],\n                  },\n                  {\n                    type: 'null',\n                  },\n                ],\n              },\n              format: {\n                type: 'string',\n                enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''], // ElementFormatType, since the root node is an element\n              },\n              indent: {\n                type: 'integer',\n              },\n              version: {\n                type: 'integer',\n              },\n            },\n            required: ['children', 'direction', 'format', 'indent', 'type', 'version'],\n          },\n        },\n        required: ['root'],\n      }\n      for (const modifyOutputSchema of finalSanitizedEditorConfig.features.generatedTypes\n        .modifyOutputSchemas) {\n        outputSchema = modifyOutputSchema({\n          collectionIDFieldTypes,\n          config,\n          currentSchema: outputSchema,\n          field,\n          interfaceNameDefinitions,\n          isRequired,\n        })\n      }\n\n      return outputSchema\n    },\n    populationPromise({\n      context,\n      currentDepth,\n      depth,\n      field,\n      findMany,\n      flattenLocales,\n      overrideAccess,\n      populationPromises,\n      req,\n      showHiddenFields,\n      siblingDoc,\n    }) {\n      // check if there are any features with nodes which have populationPromises for this field\n      if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {\n        return richTextRelationshipPromise({\n          context,\n          currentDepth,\n          depth,\n          editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,\n          field,\n          findMany,\n          flattenLocales,\n          overrideAccess,\n          populationPromises,\n          req,\n          showHiddenFields,\n          siblingDoc,\n        })\n      }\n\n      return null\n    },\n    validate: richTextValidateHOC({\n      editorConfig: finalSanitizedEditorConfig,\n    }),\n  }\n}\n\nexport { AlignFeature } from './field/features/align/feature.server.js'\nexport { BlockQuoteFeature } from './field/features/blockquote/feature.server.js'\nexport {\n  BlocksFeature,\n  type BlocksFeatureProps,\n  type LexicalBlock,\n} from './field/features/blocks/feature.server.js'\nexport {\n  $createBlockNode,\n  $isBlockNode,\n  type BlockFields,\n  BlockNode,\n  type SerializedBlockNode,\n} from './field/features/blocks/nodes/BlocksNode.js'\n\nexport { TextDropdownSectionWithEntries } from './field/features/common/floatingSelectToolbarTextDropdownSection/index.js'\nexport { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'\n\nexport { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'\nexport { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './field/features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './field/features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './field/features/converters/html/feature.server.js'\nexport {\n  consolidateHTMLConverters,\n  lexicalHTML,\n} from './field/features/converters/html/field/index.js'\nexport { createClientComponent } from './field/features/createClientComponent.js'\nexport { TestRecorderFeature } from './field/features/debug/testrecorder/feature.server.js'\nexport { TreeViewFeature } from './field/features/debug/treeview/feature.server.js'\nexport { BoldFeature } from './field/features/format/bold/feature.server.js'\nexport { SectionWithEntries as FormatSectionWithEntries } from './field/features/format/common/floatingSelectToolbarSection.js'\nexport { InlineCodeFeature } from './field/features/format/inlinecode/feature.server.js'\nexport { ItalicFeature } from './field/features/format/italic/feature.server.js'\nexport { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './field/features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './field/features/format/underline/feature.server.js'\n\nexport { HeadingFeature } from './field/features/heading/feature.server.js'\nexport { IndentFeature } from './field/features/indent/feature.server.js'\n\nexport { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './field/features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './field/features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './field/features/link/nodes/types.js'\nexport { CheckListFeature } from './field/features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './field/features/lists/orderedlist/feature.server.js'\nexport { UnorderedListFeature } from './field/features/lists/unorderedlist/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\n\nexport { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'\nexport { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './field/features/migrations/slateToLexical/converter/index.js'\n\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './field/features/migrations/slateToLexical/converter/types.js'\nexport { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'\nexport { ParagraphFeature } from './field/features/paragraph/feature.server.js'\nexport { RelationshipFeature } from './field/features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './field/features/relationship/nodes/RelationshipNode.js'\nexport type {\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  NodeValidation,\n  PopulationPromise,\n  ResolvedClientFeature,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeature,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedPlugin,\n  SanitizedServerFeatures,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from './field/features/types.js'\nexport { UploadFeature } from './field/features/upload/feature.server.js'\n\nexport type { UploadFeatureProps } from './field/features/upload/feature.server.js'\n\nexport type { RawUploadPayload } from './field/features/upload/nodes/UploadNode.js'\n\nexport {\n  $createUploadNode,\n  $isUploadNode,\n  type SerializedUploadNode,\n  type UploadData,\n  UploadNode,\n} from './field/features/upload/nodes/UploadNode.js'\nexport {\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './field/lexical/config/client/EditorConfigProvider.js'\nexport {\n  sanitizeClientEditorConfig,\n  sanitizeClientFeatures,\n} from './field/lexical/config/client/sanitize.js'\nexport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultEditorLexicalConfig,\n  defaultSanitizedServerEditorConfig,\n} from './field/lexical/config/server/default.js'\nexport {\n  loadFeatures,\n  sortFeaturesForOptimalLoading,\n} from './field/lexical/config/server/loader.js'\nexport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\n\nexport type {\n  ClientEditorConfig,\n  SanitizedClientEditorConfig,\n  SanitizedServerEditorConfig,\n  ServerEditorConfig,\n} from './field/lexical/config/types.js'\nexport { getEnabledNodes } from './field/lexical/nodes/index.js'\n\nexport {\n  type FloatingToolbarSection,\n  type FloatingToolbarSectionEntry,\n} from './field/lexical/plugins/FloatingSelectToolbar/types.js'\nexport { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type { AdapterProps }\n\nexport {\n  SlashMenuGroup,\n  SlashMenuOption,\n} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nexport { CAN_USE_DOM } from './field/lexical/utils/canUseDOM.js'\nexport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nexport { getDOMRangeRect } from './field/lexical/utils/getDOMRangeRect.js'\nexport { getSelectedNode } from './field/lexical/utils/getSelectedNode.js'\nexport { isHTMLElement } from './field/lexical/utils/guard.js'\nexport { invariant } from './field/lexical/utils/invariant.js'\nexport { joinClasses } from './field/lexical/utils/joinClasses.js'\nexport { createBlockNode } from './field/lexical/utils/markdown/createBlockNode.js'\nexport {\n  DETAIL_TYPE_TO_DETAIL,\n  DOUBLE_LINE_BREAK,\n  ELEMENT_FORMAT_TO_TYPE,\n  ELEMENT_TYPE_TO_FORMAT,\n  IS_ALL_FORMATTING,\n  LTR_REGEX,\n  NON_BREAKING_SPACE,\n  NodeFormat,\n  RTL_REGEX,\n  TEXT_MODE_TO_TYPE,\n  TEXT_TYPE_TO_FORMAT,\n  TEXT_TYPE_TO_MODE,\n} from './field/lexical/utils/nodeFormat.js'\nexport { Point, isPoint } from './field/lexical/utils/point.js'\nexport { Rect } from './field/lexical/utils/rect.js'\nexport { setFloatingElemPosition } from './field/lexical/utils/setFloatingElemPosition.js'\nexport { setFloatingElemPositionForLinkEditor } from './field/lexical/utils/setFloatingElemPositionForLinkEditor.js'\nexport {\n  addSwipeDownListener,\n  addSwipeLeftListener,\n  addSwipeRightListener,\n  addSwipeUpListener,\n} from './field/lexical/utils/swipe.js'\nexport { sanitizeUrl, validateUrl } from './field/lexical/utils/url.js'\nexport { defaultRichTextValue } from './populate/defaultValue.js'\n\nexport type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n"],"names":["withMergedProps","withNullableJSONSchemaType","RichTextCell","RichTextField","defaultEditorConfig","defaultEditorFeatures","defaultSanitizedServerEditorConfig","loadFeatures","sanitizeServerFeatures","cloneDeep","getGenerateComponentMap","getGenerateSchemaMap","richTextRelationshipPromise","richTextValidateHOC","lexicalEditor","props","resolvedFeatureMap","finalSanitizedEditorConfig","features","lexical","defaultFeatures","unSanitizedEditorConfig","CellComponent","Component","toMergeIntoProps","lexicalEditorConfig","FieldComponent","afterReadPromise","field","incomingEditorState","siblingDoc","Promise","resolve","reject","promises","hooks","afterReadPromises","length","promise","push","all","then","catch","error","editorConfig","generateComponentMap","generateSchemaMap","outputSchema","collectionIDFieldTypes","config","interfaceNameDefinitions","isRequired","type","properties","root","additionalProperties","children","items","version","required","direction","oneOf","enum","format","indent","modifyOutputSchema","generatedTypes","modifyOutputSchemas","currentSchema","populationPromise","context","currentDepth","depth","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","size","editorPopulationPromises","validate","AlignFeature","BlockQuoteFeature","BlocksFeature","$createBlockNode","$isBlockNode","BlockNode","TextDropdownSectionWithEntries","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","createClientComponent","TestRecorderFeature","TreeViewFeature","BoldFeature","SectionWithEntries","FormatSectionWithEntries","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","IndentFeature","LinkFeature","$createAutoLinkNode","$isAutoLinkNode","AutoLinkNode","$createLinkNode","$isLinkNode","LinkNode","TOGGLE_LINK_COMMAND","CheckListFeature","OrderedListFeature","UnorderedListFeature","LexicalPluginToLexicalFeature","SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters","convertSlateNodesToLexical","convertSlateToLexical","SlateToLexicalFeature","ParagraphFeature","RelationshipFeature","$createRelationshipNode","$isRelationshipNode","RelationshipNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","EditorConfigProvider","useEditorConfigContext","sanitizeClientEditorConfig","sanitizeClientFeatures","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","sanitizeServerEditorConfig","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","SlashMenuGroup","SlashMenuOption","CAN_USE_DOM","getDOMRangeRect","getSelectedNode","isHTMLElement","invariant","joinClasses","createBlockNode","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","Point","isPoint","Rect","setFloatingElemPosition","setFloatingElemPositionForLinkEditor","addSwipeDownListener","addSwipeLeftListener","addSwipeRightListener","addSwipeUpListener","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport { withMergedProps } from '@payloadcms/ui/elements/withMergedProps'\nimport { withNullableJSONSchemaType } from 'payload/utilities'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from './field/features/types.js'\nimport type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'\nimport type {\n  AdapterProps,\n  LexicalEditorProps,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from './types.js'\n\nimport { RichTextCell } from './cell/index.js'\nimport { RichTextField } from './field/index.js'\nimport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n} from './field/lexical/config/server/default.js'\nimport { loadFeatures } from './field/lexical/config/server/loader.js'\nimport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nimport { getGenerateComponentMap } from './generateComponentMap.js'\nimport { getGenerateSchemaMap } from './generateSchemaMap.js'\nimport { i18n } from './i18n.js'\nimport { populateLexicalPopulationPromises } from './populate/populateLexicalPopulationPromises.js'\nimport { richTextValidateHOC } from './validate/index.js'\n\nlet defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig = null\n\nexport function lexicalEditor(props?: LexicalEditorProps): LexicalRichTextAdapterProvider {\n  return async ({ config, isRoot }) => {\n    let features: FeatureProviderServer<unknown, unknown>[] = []\n    let resolvedFeatureMap: ResolvedServerFeatureMap\n\n    let finalSanitizedEditorConfig: SanitizedServerEditorConfig // For server only\n    if (!props || (!props.features && !props.lexical)) {\n      if (!defaultSanitizedServerEditorConfig) {\n        defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(\n          defaultEditorConfig,\n          config,\n        )\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)\n\n      resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap\n    } else {\n      const rootEditor = config.editor\n      let rootEditorFeatures: FeatureProviderServer<unknown, unknown>[] = []\n      if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n        rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n      }\n\n      features =\n        props.features && typeof props.features === 'function'\n          ? props.features({\n              defaultFeatures: cloneDeep(defaultEditorFeatures),\n              rootFeatures: rootEditorFeatures,\n            })\n          : (props.features as FeatureProviderServer<unknown, unknown>[])\n      if (!features) {\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      const lexical: LexicalEditorConfig = props.lexical\n\n      resolvedFeatureMap = await loadFeatures({\n        config,\n        isRoot,\n        unSanitizedEditorConfig: {\n          features,\n          lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        },\n      })\n\n      finalSanitizedEditorConfig = {\n        features: sanitizeServerFeatures(resolvedFeatureMap),\n        lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        resolvedFeatureMap,\n      }\n    }\n\n    const featureI18n = finalSanitizedEditorConfig.features.i18n\n    for (const lang in i18n) {\n      if (!featureI18n[lang]) {\n        featureI18n[lang] = {\n          lexical: {},\n        }\n      }\n\n      featureI18n[lang].lexical.general = i18n[lang]\n    }\n\n    return {\n      CellComponent: withMergedProps({\n        Component: RichTextCell,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      FieldComponent: withMergedProps({\n        Component: RichTextField,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      editorConfig: finalSanitizedEditorConfig,\n      features,\n      generateComponentMap: getGenerateComponentMap({\n        resolvedFeatureMap,\n      }),\n      generateSchemaMap: getGenerateSchemaMap({\n        resolvedFeatureMap,\n      }),\n      i18n: featureI18n,\n      /* hooks: {\n        afterChange: finalSanitizedEditorConfig.features.hooks.afterChange,\n        afterRead: finalSanitizedEditorConfig.features.hooks.afterRead,\n        beforeChange: finalSanitizedEditorConfig.features.hooks.beforeChange,\n        beforeDuplicate: finalSanitizedEditorConfig.features.hooks.beforeDuplicate,\n        beforeValidate: finalSanitizedEditorConfig.features.hooks.beforeValidate,\n      },*/\n      /* // TODO: Figure out docWithLocales / originalSiblingDoc => node matching. Can't use indexes, as the order of nodes could technically change between hooks.\n      hooks: {\n        afterChange: [\n          async ({ context, findMany, operation, overrideAccess, req, value }) => {\n            await recurseNodesAsync({\n              callback: async (node) => {\n                const afterChangeHooks = finalSanitizedEditorConfig.features.hooks.afterChange\n                if (afterChangeHooks?.has(node.type)) {\n                  for (const hook of afterChangeHooks.get(node.type)) {\n                    node = await hook({ context, findMany, node, operation, overrideAccess, req })\n                  }\n                }\n              },\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            return value\n          },\n        ],\n        afterRead: [\n          async ({ context, findMany, operation, overrideAccess, req, value }) => {\n            await recurseNodesAsync({\n              callback: async (node) => {\n                const afterReadHooks = finalSanitizedEditorConfig.features.hooks.afterRead\n                if (afterReadHooks?.has(node.type)) {\n                  for (const hook of afterReadHooks.get(node.type)) {\n                    node = await hook({ context, findMany, node, operation, overrideAccess, req })\n                  }\n                }\n              },\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            return value\n          },\n        ],\n        beforeChange: [\n          async ({ context, findMany, operation, overrideAccess, req, value }) => {\n            await recurseNodesAsync({\n              callback: async (node) => {\n                const beforeChangeHooks = finalSanitizedEditorConfig.features.hooks.beforeChange\n                if (beforeChangeHooks?.has(node.type)) {\n                  for (const hook of beforeChangeHooks.get(node.type)) {\n                    node = await hook({ context, findMany, node, operation, overrideAccess, req })\n                  }\n                }\n              },\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            return value\n          },\n        ],\n        beforeDuplicate: [\n          async ({ context, findMany, operation, overrideAccess, req, value }) => {\n            await recurseNodesAsync({\n              callback: async (node) => {\n                const beforeDuplicateHooks = finalSanitizedEditorConfig.features.hooks.beforeDuplicate\n                if (beforeDuplicateHooks?.has(node.type)) {\n                  for (const hook of beforeDuplicateHooks.get(node.type)) {\n                    node = await hook({ context, findMany, node, operation, overrideAccess, req })\n                  }\n                }\n              },\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            return value\n          },\n        ],\n        beforeValidate: [\n          async ({ context, findMany, operation, overrideAccess, req, value }) => {\n            await recurseNodesAsync({\n              callback: async (node) => {\n                const beforeValidateHooks = finalSanitizedEditorConfig.features.hooks.beforeValidate\n                if (beforeValidateHooks?.has(node.type)) {\n                  for (const hook of beforeValidateHooks.get(node.type)) {\n                    /**\n                     * 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\n                     */ /*\n                  node = await hook({ context, findMany, node, operation, overrideAccess, req })\n                }\n              }\n            },\n            nodes: (value as SerializedEditorState)?.root?.children ?? [],\n          })\n\n          return value\n        },\n      ],\n    },*/\n      outputSchema: ({\n        collectionIDFieldTypes,\n        config,\n        field,\n        interfaceNameDefinitions,\n        isRequired,\n      }) => {\n        let outputSchema: JSONSchema4 = {\n          // This schema matches the SerializedEditorState type so far, that it's possible to cast SerializedEditorState to this schema without any errors.\n          // In the future, we should\n          // 1) allow recursive children\n          // 2) Pass in all the different types for every node added to the editorconfig. This can be done with refs in the schema.\n          type: withNullableJSONSchemaType('object', isRequired),\n          properties: {\n            root: {\n              type: 'object',\n              additionalProperties: false,\n              properties: {\n                type: {\n                  type: 'string',\n                },\n                children: {\n                  type: 'array',\n                  items: {\n                    type: 'object',\n                    additionalProperties: true,\n                    properties: {\n                      type: {\n                        type: 'string',\n                      },\n                      version: {\n                        type: 'integer',\n                      },\n                    },\n                    required: ['type', 'version'],\n                  },\n                },\n                direction: {\n                  oneOf: [\n                    {\n                      enum: ['ltr', 'rtl'],\n                    },\n                    {\n                      type: 'null',\n                    },\n                  ],\n                },\n                format: {\n                  type: 'string',\n                  enum: ['left', 'start', 'center', 'right', 'end', 'justify', ''], // ElementFormatType, since the root node is an element\n                },\n                indent: {\n                  type: 'integer',\n                },\n                version: {\n                  type: 'integer',\n                },\n              },\n              required: ['children', 'direction', 'format', 'indent', 'type', 'version'],\n            },\n          },\n          required: ['root'],\n        }\n        for (const modifyOutputSchema of finalSanitizedEditorConfig.features.generatedTypes\n          .modifyOutputSchemas) {\n          outputSchema = modifyOutputSchema({\n            collectionIDFieldTypes,\n            config,\n            currentSchema: outputSchema,\n            field,\n            interfaceNameDefinitions,\n            isRequired,\n          })\n        }\n\n        return outputSchema\n      },\n      populationPromises({\n        context,\n        currentDepth,\n        depth,\n        draft,\n        field,\n        fieldPromises,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        req,\n        showHiddenFields,\n        siblingDoc,\n      }) {\n        // check if there are any features with nodes which have populationPromises for this field\n        if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {\n          populateLexicalPopulationPromises({\n            context,\n            currentDepth,\n            depth,\n            draft,\n            editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            overrideAccess,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      },\n      validate: richTextValidateHOC({\n        editorConfig: finalSanitizedEditorConfig,\n      }),\n    }\n  }\n}\n\nexport { AlignFeature } from './field/features/align/feature.server.js'\nexport { BlockquoteFeature } from './field/features/blockquote/feature.server.js'\nexport { BlocksFeature, type BlocksFeatureProps } from './field/features/blocks/feature.server.js'\nexport {\n  $createBlockNode,\n  $isBlockNode,\n  type BlockFields,\n  BlockNode,\n  type SerializedBlockNode,\n} from './field/features/blocks/nodes/BlocksNode.js'\n\nexport { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'\nexport { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'\n\nexport { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './field/features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './field/features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './field/features/converters/html/feature.server.js'\nexport {\n  consolidateHTMLConverters,\n  lexicalHTML,\n} from './field/features/converters/html/field/index.js'\nexport { TestRecorderFeature } from './field/features/debug/testRecorder/feature.server.js'\nexport { TreeViewFeature } from './field/features/debug/treeView/feature.server.js'\nexport { BoldFeature } from './field/features/format/bold/feature.server.js'\nexport { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js'\n\nexport { ItalicFeature } from './field/features/format/italic/feature.server.js'\nexport { toolbarFormatGroupWithItems } from './field/features/format/shared/toolbarFormatGroup.js'\nexport { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './field/features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './field/features/format/underline/feature.server.js'\nexport {\n  HeadingFeature,\n  type HeadingFeatureProps,\n} from './field/features/heading/feature.server.js'\nexport { HorizontalRuleFeature } from './field/features/horizontalRule/feature.server.js'\n\nexport { IndentFeature } from './field/features/indent/feature.server.js'\nexport { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'\n\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './field/features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './field/features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './field/features/link/nodes/types.js'\nexport { ChecklistFeature } from './field/features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './field/features/lists/orderedList/feature.server.js'\nexport { UnorderedListFeature } from './field/features/lists/unorderedList/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\nexport { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'\nexport { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'\n\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './field/features/migrations/slateToLexical/converter/index.js'\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './field/features/migrations/slateToLexical/converter/types.js'\nexport { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'\n\nexport { ParagraphFeature } from './field/features/paragraph/feature.server.js'\nexport {\n  RelationshipFeature,\n  type RelationshipFeatureProps,\n} from './field/features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './field/features/relationship/nodes/RelationshipNode.js'\nexport { toolbarAddDropdownGroupWithItems } from './field/features/shared/toolbar/addDropdownGroup.js'\nexport { toolbarFeatureButtonsGroupWithItems } from './field/features/shared/toolbar/featureButtonsGroup.js'\n\nexport { toolbarTextDropdownGroupWithItems } from './field/features/shared/toolbar/textDropdownGroup.js'\nexport { FixedToolbarFeature } from './field/features/toolbars/fixed/feature.server.js'\nexport { InlineToolbarFeature } from './field/features/toolbars/inline/feature.server.js'\n\nexport type { ToolbarGroup, ToolbarGroupItem } from './field/features/toolbars/types.js'\nexport { createNode } from './field/features/typeUtilities.js'\nexport type {\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  FieldNodeHook,\n  FieldNodeHookArgs,\n  NodeValidation,\n  NodeWithHooks,\n  PluginComponent,\n  PluginComponentWithAnchor,\n  PopulationPromise,\n  ResolvedClientFeature,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeature,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedPlugin,\n  SanitizedServerFeatures,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from './field/features/types.js'\n\nexport { UploadFeature } from './field/features/upload/feature.server.js'\n\nexport type { UploadFeatureProps } from './field/features/upload/feature.server.js'\nexport {\n  $createUploadNode,\n  $isUploadNode,\n  type SerializedUploadNode,\n  type UploadData,\n  UploadNode,\n} from './field/features/upload/nodes/UploadNode.js'\n\nexport {\n  type EditorConfigContextType,\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './field/lexical/config/client/EditorConfigProvider.js'\nexport {\n  sanitizeClientEditorConfig,\n  sanitizeClientFeatures,\n} from './field/lexical/config/client/sanitize.js'\nexport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultEditorLexicalConfig,\n} from './field/lexical/config/server/default.js'\nexport {\n  loadFeatures,\n  sortFeaturesForOptimalLoading,\n} from './field/lexical/config/server/loader.js'\n\nexport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\nexport type {\n  ClientEditorConfig,\n  SanitizedClientEditorConfig,\n  SanitizedServerEditorConfig,\n  ServerEditorConfig,\n} from './field/lexical/config/types.js'\n\nexport { getEnabledNodes } from './field/lexical/nodes/index.js'\nexport { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type { AdapterProps }\n\nexport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nexport { CAN_USE_DOM } from './field/lexical/utils/canUseDOM.js'\nexport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nexport { getDOMRangeRect } from './field/lexical/utils/getDOMRangeRect.js'\nexport { getSelectedNode } from './field/lexical/utils/getSelectedNode.js'\nexport { isHTMLElement } from './field/lexical/utils/guard.js'\nexport { invariant } from './field/lexical/utils/invariant.js'\nexport { joinClasses } from './field/lexical/utils/joinClasses.js'\nexport { createBlockNode } from './field/lexical/utils/markdown/createBlockNode.js'\nexport {\n  DETAIL_TYPE_TO_DETAIL,\n  DOUBLE_LINE_BREAK,\n  ELEMENT_FORMAT_TO_TYPE,\n  ELEMENT_TYPE_TO_FORMAT,\n  IS_ALL_FORMATTING,\n  LTR_REGEX,\n  NON_BREAKING_SPACE,\n  NodeFormat,\n  RTL_REGEX,\n  TEXT_MODE_TO_TYPE,\n  TEXT_TYPE_TO_FORMAT,\n  TEXT_TYPE_TO_MODE,\n} from './field/lexical/utils/nodeFormat.js'\nexport { Point, isPoint } from './field/lexical/utils/point.js'\nexport { Rect } from './field/lexical/utils/rect.js'\nexport { setFloatingElemPosition } from './field/lexical/utils/setFloatingElemPosition.js'\nexport { setFloatingElemPositionForLinkEditor } from './field/lexical/utils/setFloatingElemPositionForLinkEditor.js'\nexport {\n  addSwipeDownListener,\n  addSwipeLeftListener,\n  addSwipeRightListener,\n  addSwipeUpListener,\n} from './field/lexical/utils/swipe.js'\nexport { sanitizeUrl, validateUrl } from './field/lexical/utils/url.js'\nexport { defaultRichTextValue } from './populate/defaultValue.js'\n\nexport type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n"],"names":["withMergedProps","withNullableJSONSchemaType","RichTextCell","RichTextField","defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerEditorConfig","sanitizeServerFeatures","cloneDeep","getGenerateComponentMap","getGenerateSchemaMap","i18n","populateLexicalPopulationPromises","richTextValidateHOC","defaultSanitizedServerEditorConfig","lexicalEditor","props","config","isRoot","features","resolvedFeatureMap","finalSanitizedEditorConfig","lexical","rootEditor","editor","rootEditorFeatures","defaultFeatures","rootFeatures","unSanitizedEditorConfig","featureI18n","lang","general","CellComponent","Component","toMergeIntoProps","admin","lexicalEditorConfig","FieldComponent","editorConfig","generateComponentMap","generateSchemaMap","outputSchema","collectionIDFieldTypes","field","interfaceNameDefinitions","isRequired","type","properties","root","additionalProperties","children","items","version","required","direction","oneOf","enum","format","indent","modifyOutputSchema","generatedTypes","modifyOutputSchemas","currentSchema","populationPromises","context","currentDepth","depth","draft","fieldPromises","findMany","flattenLocales","overrideAccess","req","showHiddenFields","siblingDoc","size","editorPopulationPromises","validate","AlignFeature","BlockquoteFeature","BlocksFeature","$createBlockNode","$isBlockNode","BlockNode","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","TestRecorderFeature","TreeViewFeature","BoldFeature","InlineCodeFeature","ItalicFeature","toolbarFormatGroupWithItems","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","$createAutoLinkNode","$isAutoLinkNode","AutoLinkNode","$createLinkNode","$isLinkNode","LinkNode","TOGGLE_LINK_COMMAND","ChecklistFeature","OrderedListFeature","UnorderedListFeature","LexicalPluginToLexicalFeature","SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters","convertSlateNodesToLexical","convertSlateToLexical","SlateToLexicalFeature","ParagraphFeature","RelationshipFeature","$createRelationshipNode","$isRelationshipNode","RelationshipNode","toolbarAddDropdownGroupWithItems","toolbarFeatureButtonsGroupWithItems","toolbarTextDropdownGroupWithItems","FixedToolbarFeature","InlineToolbarFeature","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","EditorConfigProvider","useEditorConfigContext","sanitizeClientEditorConfig","sanitizeClientFeatures","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","CAN_USE_DOM","getDOMRangeRect","getSelectedNode","isHTMLElement","invariant","joinClasses","createBlockNode","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","Point","isPoint","Rect","setFloatingElemPosition","setFloatingElemPositionForLinkEditor","addSwipeDownListener","addSwipeLeftListener","addSwipeRightListener","addSwipeUpListener","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/populate/defaultValue.d.ts

@@ -1,4 +1,3 @@
 import type { SerializedEditorState } from 'lexical';
 export declare const defaultRichTextValue: SerializedEditorState;
-export declare const defaultRichTextValueV2: SerializedEditorState;
 //# sourceMappingURL=defaultValue.d.ts.map

package/dist/populate/defaultValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultValue.d.ts","sourceRoot":"","sources":["../../src/populate/defaultValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAA+C,MAAM,SAAS,CAAA;AAEjG,eAAO,MAAM,oBAAoB,EAAE,qBA4BlC,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,qBAkBpC,CAAA"}
+{"version":3,"file":"defaultValue.d.ts","sourceRoot":"","sources":["../../src/populate/defaultValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAA+C,MAAM,SAAS,CAAA;AAEjG,eAAO,MAAM,oBAAoB,EAAE,qBA6BlC,CAAA"}

package/dist/populate/defaultValue.js

@@ -18,25 +18,7 @@ export const defaultRichTextValue = {
                 direction: null,
                 format: '',
                 indent: 0,
-                version: 1
-            }
-        ],
-        direction: null,
-        format: '',
-        indent: 0,
-        version: 1
-    }
-};
-export const defaultRichTextValueV2 = {
-    root: {
-        type: 'root',
-        children: [
-            {
-                type: 'paragraph',
-                children: [],
-                direction: null,
-                format: '',
-                indent: 0,
+                textFormat: 0,
                 version: 1
             }
         ],

package/dist/populate/defaultValue.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/populate/defaultValue.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedParagraphNode, SerializedTextNode } from 'lexical'\n\nexport const defaultRichTextValue: SerializedEditorState = {\n  root: {\n    type: 'root',\n    children: [\n      {\n        type: 'paragraph',\n        children: [\n          {\n            type: 'text',\n            detail: 0,\n            format: 0,\n            mode: 'normal',\n            style: '',\n            text: '',\n            version: 1,\n          } as SerializedTextNode,\n        ],\n        direction: null,\n        format: '',\n        indent: 0,\n        version: 1,\n      } as SerializedParagraphNode,\n    ],\n    direction: null,\n    format: '',\n    indent: 0,\n    version: 1,\n  },\n}\n\nexport const defaultRichTextValueV2: SerializedEditorState = {\n  root: {\n    type: 'root',\n    children: [\n      {\n        type: 'paragraph',\n        children: [],\n        direction: null,\n        format: '',\n        indent: 0,\n        version: 1,\n      } as SerializedParagraphNode,\n    ],\n    direction: null,\n    format: '',\n    indent: 0,\n    version: 1,\n  },\n}\n"],"names":["defaultRichTextValue","root","type","children","detail","format","mode","style","text","version","direction","indent","defaultRichTextValueV2"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,uBAA8C;IACzDC,MAAM;QACJC,MAAM;QACNC,UAAU;YACR;gBACED,MAAM;gBACNC,UAAU;oBACR;wBACED,MAAM;wBACNE,QAAQ;wBACRC,QAAQ;wBACRC,MAAM;wBACNC,OAAO;wBACPC,MAAM;wBACNC,SAAS;oBACX;iBACD;gBACDC,WAAW;gBACXL,QAAQ;gBACRM,QAAQ;gBACRF,SAAS;YACX;SACD;QACDC,WAAW;QACXL,QAAQ;QACRM,QAAQ;QACRF,SAAS;IACX;AACF,EAAC;AAED,OAAO,MAAMG,yBAAgD;IAC3DX,MAAM;QACJC,MAAM;QACNC,UAAU;YACR;gBACED,MAAM;gBACNC,UAAU,EAAE;gBACZO,WAAW;gBACXL,QAAQ;gBACRM,QAAQ;gBACRF,SAAS;YACX;SACD;QACDC,WAAW;QACXL,QAAQ;QACRM,QAAQ;QACRF,SAAS;IACX;AACF,EAAC"}
+{"version":3,"sources":["../../src/populate/defaultValue.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedParagraphNode, SerializedTextNode } from 'lexical'\n\nexport const defaultRichTextValue: SerializedEditorState = {\n  root: {\n    type: 'root',\n    children: [\n      {\n        type: 'paragraph',\n        children: [\n          {\n            type: 'text',\n            detail: 0,\n            format: 0,\n            mode: 'normal',\n            style: '',\n            text: '',\n            version: 1,\n          } as SerializedTextNode,\n        ],\n        direction: null,\n        format: '',\n        indent: 0,\n        textFormat: 0,\n        version: 1,\n      } as SerializedParagraphNode,\n    ],\n    direction: null,\n    format: '',\n    indent: 0,\n    version: 1,\n  },\n}\n"],"names":["defaultRichTextValue","root","type","children","detail","format","mode","style","text","version","direction","indent","textFormat"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,uBAA8C;IACzDC,MAAM;QACJC,MAAM;QACNC,UAAU;YACR;gBACED,MAAM;gBACNC,UAAU;oBACR;wBACED,MAAM;wBACNE,QAAQ;wBACRC,QAAQ;wBACRC,MAAM;wBACNC,OAAO;wBACPC,MAAM;wBACNC,SAAS;oBACX;iBACD;gBACDC,WAAW;gBACXL,QAAQ;gBACRM,QAAQ;gBACRC,YAAY;gBACZH,SAAS;YACX;SACD;QACDC,WAAW;QACXL,QAAQ;QACRM,QAAQ;QACRF,SAAS;IACX;AACF,EAAC"}

package/dist/populate/populate.d.ts

@@ -1,21 +1,22 @@
 import type { SerializedEditorState } from 'lexical';
-import type { PayloadRequest } from 'payload/types';
+import type { PayloadRequestWithData } from 'payload/types';
 import type { Collection, Field, RichTextField } from 'payload/types';
 import type { AdapterProps } from '../types.js';
 type Arguments = {
     currentDepth?: number;
     data: unknown;
     depth: number;
+    draft: boolean;
     field: RichTextField<SerializedEditorState, AdapterProps>;
     key: number | string;
     overrideAccess?: boolean;
-    req: PayloadRequest;
+    req: PayloadRequestWithData;
     showHiddenFields: boolean;
 };
-export declare const populate: ({ id, collection, currentDepth, data, depth, key, overrideAccess, req, showHiddenFields, }: Omit<Arguments, 'field'> & {
+export declare const populate: ({ id, collection, currentDepth, data, depth, draft, key, overrideAccess, req, showHiddenFields, }: Omit<Arguments, 'field'> & {
     collection: Collection;
     field: Field;
-    id: string;
+    id: number | string;
 }) => Promise<void>;
 export {};
 //# sourceMappingURL=populate.d.ts.map

package/dist/populate/populate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populate.d.ts","sourceRoot":"","sources":["../../src/populate/populate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAErE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,KAAK,SAAS,GAAG;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAA;IACzD,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,+FAUlB,KAAK,SAAS,EAAE,OAAO,CAAC,GAAG;IAC5B,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,KAAK,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,KAAG,QAAQ,IAAI,CAsBf,CAAA"}
+{"version":3,"file":"populate.d.ts","sourceRoot":"","sources":["../../src/populate/populate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAIrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,KAAK,SAAS,GAAG;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,KAAK,EAAE,aAAa,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAA;IACzD,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,EAAE,sBAAsB,CAAA;IAC3B,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,sGAWlB,KAAK,SAAS,EAAE,OAAO,CAAC,GAAG;IAC5B,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,KAAK,CAAA;IACZ,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CACpB,KAAG,QAAQ,IAAI,CAuBf,CAAA"}

package/dist/populate/populate.js

@@ -1,16 +1,18 @@
-export const populate = async ({ id, collection, currentDepth, data, depth, key, overrideAccess, req, showHiddenFields })=>{
+import { createDataloaderCacheKey } from 'payload/utilities';
+export const populate = async ({ id, collection, currentDepth, data, depth, draft, key, overrideAccess, req, showHiddenFields })=>{
     const dataRef = data;
-    const doc = await req.payloadDataLoader.load(JSON.stringify([
-        req.transactionID,
-        collection.config.slug,
-        id,
+    const doc = await req.payloadDataLoader.load(createDataloaderCacheKey({
+        collectionSlug: collection.config.slug,
+        currentDepth: currentDepth + 1,
         depth,
-        currentDepth + 1,
-        req.locale,
-        req.fallbackLocale,
-        typeof overrideAccess === 'undefined' ? false : overrideAccess,
-        showHiddenFields
-    ]));
+        docID: id,
+        draft,
+        fallbackLocale: req.fallbackLocale,
+        locale: req.locale,
+        overrideAccess: typeof overrideAccess === 'undefined' ? false : overrideAccess,
+        showHiddenFields,
+        transactionID: req.transactionID
+    }));
     if (doc) {
         dataRef[key] = doc;
     } else {

package/dist/populate/populate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/populate/populate.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { PayloadRequest } from 'payload/types'\nimport type { Collection, Field, RichTextField } from 'payload/types'\n\nimport type { AdapterProps } from '../types.js'\n\ntype Arguments = {\n  currentDepth?: number\n  data: unknown\n  depth: number\n  field: RichTextField<SerializedEditorState, AdapterProps>\n  key: number | string\n  overrideAccess?: boolean\n  req: PayloadRequest\n  showHiddenFields: boolean\n}\n\nexport const populate = async ({\n  id,\n  collection,\n  currentDepth,\n  data,\n  depth,\n  key,\n  overrideAccess,\n  req,\n  showHiddenFields,\n}: Omit<Arguments, 'field'> & {\n  collection: Collection\n  field: Field\n  id: string\n}): Promise<void> => {\n  const dataRef = data as Record<string, unknown>\n\n  const doc = await req.payloadDataLoader.load(\n    JSON.stringify([\n      req.transactionID,\n      collection.config.slug,\n      id,\n      depth,\n      currentDepth + 1,\n      req.locale,\n      req.fallbackLocale,\n      typeof overrideAccess === 'undefined' ? false : overrideAccess,\n      showHiddenFields,\n    ]),\n  )\n\n  if (doc) {\n    dataRef[key] = doc\n  } else {\n    dataRef[key] = null\n  }\n}\n"],"names":["populate","id","collection","currentDepth","data","depth","key","overrideAccess","req","showHiddenFields","dataRef","doc","payloadDataLoader","load","JSON","stringify","transactionID","config","slug","locale","fallbackLocale"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAiBA,OAAO,MAAMA,WAAW,OAAO,EAC7BC,EAAE,EACFC,UAAU,EACVC,YAAY,EACZC,IAAI,EACJC,KAAK,EACLC,GAAG,EACHC,cAAc,EACdC,GAAG,EACHC,gBAAgB,EAKjB;IACC,MAAMC,UAAUN;IAEhB,MAAMO,MAAM,MAAMH,IAAII,iBAAiB,CAACC,IAAI,CAC1CC,KAAKC,SAAS,CAAC;QACbP,IAAIQ,aAAa;QACjBd,WAAWe,MAAM,CAACC,IAAI;QACtBjB;QACAI;QACAF,eAAe;QACfK,IAAIW,MAAM;QACVX,IAAIY,cAAc;QAClB,OAAOb,mBAAmB,cAAc,QAAQA;QAChDE;KACD;IAGH,IAAIE,KAAK;QACPD,OAAO,CAACJ,IAAI,GAAGK;IACjB,OAAO;QACLD,OAAO,CAACJ,IAAI,GAAG;IACjB;AACF,EAAC"}
+{"version":3,"sources":["../../src/populate/populate.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { PayloadRequestWithData } from 'payload/types'\nimport type { Collection, Field, RichTextField } from 'payload/types'\n\nimport { createDataloaderCacheKey } from 'payload/utilities'\n\nimport type { AdapterProps } from '../types.js'\n\ntype Arguments = {\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  field: RichTextField<SerializedEditorState, AdapterProps>\n  key: number | string\n  overrideAccess?: boolean\n  req: PayloadRequestWithData\n  showHiddenFields: boolean\n}\n\nexport const populate = async ({\n  id,\n  collection,\n  currentDepth,\n  data,\n  depth,\n  draft,\n  key,\n  overrideAccess,\n  req,\n  showHiddenFields,\n}: Omit<Arguments, 'field'> & {\n  collection: Collection\n  field: Field\n  id: number | string\n}): Promise<void> => {\n  const dataRef = data as Record<string, unknown>\n\n  const doc = await req.payloadDataLoader.load(\n    createDataloaderCacheKey({\n      collectionSlug: collection.config.slug,\n      currentDepth: currentDepth + 1,\n      depth,\n      docID: id as string,\n      draft,\n      fallbackLocale: req.fallbackLocale,\n      locale: req.locale,\n      overrideAccess: typeof overrideAccess === 'undefined' ? false : overrideAccess,\n      showHiddenFields,\n      transactionID: req.transactionID,\n    }),\n  )\n\n  if (doc) {\n    dataRef[key] = doc\n  } else {\n    dataRef[key] = null\n  }\n}\n"],"names":["createDataloaderCacheKey","populate","id","collection","currentDepth","data","depth","draft","key","overrideAccess","req","showHiddenFields","dataRef","doc","payloadDataLoader","load","collectionSlug","config","slug","docID","fallbackLocale","locale","transactionID"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,wBAAwB,QAAQ,oBAAmB;AAgB5D,OAAO,MAAMC,WAAW,OAAO,EAC7BC,EAAE,EACFC,UAAU,EACVC,YAAY,EACZC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,GAAG,EACHC,cAAc,EACdC,GAAG,EACHC,gBAAgB,EAKjB;IACC,MAAMC,UAAUP;IAEhB,MAAMQ,MAAM,MAAMH,IAAII,iBAAiB,CAACC,IAAI,CAC1Cf,yBAAyB;QACvBgB,gBAAgBb,WAAWc,MAAM,CAACC,IAAI;QACtCd,cAAcA,eAAe;QAC7BE;QACAa,OAAOjB;QACPK;QACAa,gBAAgBV,IAAIU,cAAc;QAClCC,QAAQX,IAAIW,MAAM;QAClBZ,gBAAgB,OAAOA,mBAAmB,cAAc,QAAQA;QAChEE;QACAW,eAAeZ,IAAIY,aAAa;IAClC;IAGF,IAAIT,KAAK;QACPD,OAAO,CAACJ,IAAI,GAAGK;IACjB,OAAO;QACLD,OAAO,CAACJ,IAAI,GAAG;IACjB;AACF,EAAC"}

package/dist/populate/populateLexicalPopulationPromises.d.ts

@@ -0,0 +1,12 @@
+import type { SerializedEditorState } from 'lexical';
+import type { RichTextAdapter } from 'payload/types';
+import type { PopulationPromise } from '../field/features/types.js';
+import type { AdapterProps } from '../types.js';
+export type Args = Parameters<RichTextAdapter<SerializedEditorState, AdapterProps>['populationPromises']>[0] & {
+    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
+};
+/**
+ * Appends all new populationPromises to the populationPromises prop
+ */
+export declare const populateLexicalPopulationPromises: ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: Args) => void;
+//# sourceMappingURL=populateLexicalPopulationPromises.d.ts.map

package/dist/populate/populateLexicalPopulationPromises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populateLexicalPopulationPromises.d.ts","sourceRoot":"","sources":["../../src/populate/populateLexicalPopulationPromises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,MAAM,MAAM,IAAI,GAAG,UAAU,CAC3B,eAAe,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC,oBAAoB,CAAC,CAC3E,CAAC,CAAC,CAAC,GAAG;IACL,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;CAChE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,iCAAiC,8LAe3C,IAAI,SA+BN,CAAA"}

package/dist/populate/populateLexicalPopulationPromises.js

@@ -0,0 +1,36 @@
+import { recurseNodes } from '../forEachNodeRecursively.js';
+/**
+ * Appends all new populationPromises to the populationPromises prop
+ */ export const populateLexicalPopulationPromises = ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
+    if (depth <= 0 || currentDepth > depth) {
+        return;
+    }
+    recurseNodes({
+        callback: (node)=>{
+            if (editorPopulationPromises?.has(node.type)) {
+                for (const promise of editorPopulationPromises.get(node.type)){
+                    promise({
+                        context,
+                        currentDepth,
+                        depth,
+                        draft,
+                        editorPopulationPromises,
+                        field,
+                        fieldPromises,
+                        findMany,
+                        flattenLocales,
+                        node,
+                        overrideAccess,
+                        populationPromises,
+                        req,
+                        showHiddenFields,
+                        siblingDoc
+                    });
+                }
+            }
+        },
+        nodes: siblingDoc[field?.name]?.root?.children ?? []
+    });
+};
+
+//# sourceMappingURL=populateLexicalPopulationPromises.js.map

package/dist/populate/populateLexicalPopulationPromises.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/populate/populateLexicalPopulationPromises.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { RichTextAdapter } from 'payload/types'\n\nimport type { PopulationPromise } from '../field/features/types.js'\nimport type { AdapterProps } from '../types.js'\n\nimport { recurseNodes } from '../forEachNodeRecursively.js'\n\nexport type Args = Parameters<\n  RichTextAdapter<SerializedEditorState, AdapterProps>['populationPromises']\n>[0] & {\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n}\n\n/**\n * Appends all new populationPromises to the populationPromises prop\n */\nexport const populateLexicalPopulationPromises = ({\n  context,\n  currentDepth,\n  depth,\n  draft,\n  editorPopulationPromises,\n  field,\n  fieldPromises,\n  findMany,\n  flattenLocales,\n  overrideAccess,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: Args) => {\n  if (depth <= 0 || currentDepth > depth) {\n    return\n  }\n\n  recurseNodes({\n    callback: (node) => {\n      if (editorPopulationPromises?.has(node.type)) {\n        for (const promise of editorPopulationPromises.get(node.type)) {\n          promise({\n            context,\n            currentDepth,\n            depth,\n            draft,\n            editorPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            node,\n            overrideAccess,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      }\n    },\n    nodes: (siblingDoc[field?.name] as SerializedEditorState)?.root?.children ?? [],\n  })\n}\n"],"names":["recurseNodes","populateLexicalPopulationPromises","context","currentDepth","depth","draft","editorPopulationPromises","field","fieldPromises","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","callback","node","has","type","promise","get","nodes","name","root","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAMA,SAASA,YAAY,QAAQ,+BAA8B;AAQ3D;;CAEC,GACD,OAAO,MAAMC,oCAAoC,CAAC,EAChDC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,wBAAwB,EACxBC,KAAK,EACLC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACL;IACL,IAAIX,SAAS,KAAKD,eAAeC,OAAO;QACtC;IACF;IAEAJ,aAAa;QACXgB,UAAU,CAACC;YACT,IAAIX,0BAA0BY,IAAID,KAAKE,IAAI,GAAG;gBAC5C,KAAK,MAAMC,WAAWd,yBAAyBe,GAAG,CAACJ,KAAKE,IAAI,EAAG;oBAC7DC,QAAQ;wBACNlB;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAO;wBACAN;wBACAC;wBACAC;wBACAC;wBACAC;oBACF;gBACF;YACF;QACF;QACAO,OAAO,AAACP,UAAU,CAACR,OAAOgB,KAAK,EAA4BC,MAAMC,YAAY,EAAE;IACjF;AACF,EAAC"}

package/dist/populate/recurseNestedFields.d.ts

@@ -1,25 +1,29 @@
 import type { RequestContext } from 'payload';
-import type { Field, PayloadRequest } from 'payload/types';
+import type { Field, PayloadRequestWithData } from 'payload/types';
 import type { PopulationPromise } from '../field/features/types.js';
 type NestedRichTextFieldsArgs = {
     context: RequestContext;
     currentDepth?: number;
     data: unknown;
     depth: number;
+    draft: boolean;
     /**
      * This maps all the population promises to the node types
      */
     editorPopulationPromises: Map<string, Array<PopulationPromise>>;
+    /**
+     * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises
+     */
+    fieldPromises: Promise<void>[];
     fields: Field[];
     findMany: boolean;
     flattenLocales: boolean;
     overrideAccess: boolean;
     populationPromises: Promise<void>[];
-    promises: Promise<void>[];
-    req: PayloadRequest;
+    req: PayloadRequestWithData;
     showHiddenFields: boolean;
     siblingDoc: Record<string, unknown>;
 };
-export declare const recurseNestedFields: ({ context, currentDepth, data, depth, fields, findMany, flattenLocales, overrideAccess, populationPromises, promises, req, showHiddenFields, siblingDoc, }: NestedRichTextFieldsArgs) => void;
+export declare const recurseNestedFields: ({ context, currentDepth, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: NestedRichTextFieldsArgs) => void;
 export {};
 //# sourceMappingURL=recurseNestedFields.d.ts.map

package/dist/populate/recurseNestedFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurseNestedFields.d.ts","sourceRoot":"","sources":["../../src/populate/recurseNestedFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAI1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,cAAc,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb;;OAEG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACnC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC,CAAA;AAED,eAAO,MAAM,mBAAmB,+JAc7B,wBAAwB,KAAG,IAsB7B,CAAA"}
+{"version":3,"file":"recurseNestedFields.d.ts","sourceRoot":"","sources":["../../src/populate/recurseNestedFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAIlE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEnE,KAAK,wBAAwB,GAAG;IAC9B,OAAO,EAAE,cAAc,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd;;OAEG;IACH,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAA;IAC/D;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IAC9B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACnC,GAAG,EAAE,sBAAsB,CAAA;IAC3B,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC,CAAA;AAED,eAAO,MAAM,mBAAmB,2KAe7B,wBAAwB,KAAG,IAuB7B,CAAA"}

package/dist/populate/recurseNestedFields.js

@@ -1,13 +1,14 @@
 import { afterReadTraverseFields } from 'payload/utilities';
-export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, promises, req, showHiddenFields, siblingDoc })=>{
+export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, req, showHiddenFields, siblingDoc })=>{
     afterReadTraverseFields({
         collection: null,
         context,
         currentDepth,
         depth,
         doc: data,
+        draft,
         fallbackLocale: req.fallbackLocale,
-        fieldPromises: promises,
+        fieldPromises,
         fields,
         findMany,
         flattenLocales,
@@ -17,9 +18,7 @@ export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, fi
         populationPromises,
         req,
         showHiddenFields,
-        siblingDoc,
-        triggerAccessControl: false,
-        triggerHooks: false
+        siblingDoc
     });
 };
 

package/dist/populate/recurseNestedFields.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/populate/recurseNestedFields.ts"],"sourcesContent":["import type { RequestContext } from 'payload'\nimport type { Field, PayloadRequest } from 'payload/types'\n\nimport { afterReadTraverseFields } from 'payload/utilities'\n\nimport type { PopulationPromise } from '../field/features/types.js'\n\ntype NestedRichTextFieldsArgs = {\n  context: RequestContext\n  currentDepth?: number\n  data: unknown\n  depth: number\n  /**\n   * This maps all the population promises to the node types\n   */\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  fields: Field[]\n  findMany: boolean\n  flattenLocales: boolean\n  overrideAccess: boolean\n  populationPromises: Promise<void>[]\n  promises: Promise<void>[]\n  req: PayloadRequest\n  showHiddenFields: boolean\n  siblingDoc: Record<string, unknown>\n}\n\nexport const recurseNestedFields = ({\n  context,\n  currentDepth = 0,\n  data,\n  depth,\n  fields,\n  findMany,\n  flattenLocales,\n  overrideAccess = false,\n  populationPromises,\n  promises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: NestedRichTextFieldsArgs): void => {\n  afterReadTraverseFields({\n    collection: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    context,\n    currentDepth,\n    depth,\n    doc: data as any, // Looks like it's only needed for hooks and access control, so doesn't matter what we pass here right now\n    fallbackLocale: req.fallbackLocale,\n    fieldPromises: promises, // Not sure if what I pass in here makes sense. But it doesn't seem like it's used at all anyways\n    fields,\n    findMany,\n    flattenLocales,\n    global: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    locale: req.locale,\n    overrideAccess,\n    populationPromises, // This is not the same as populationPromises passed into this recurseNestedFields. These are just promises resolved at the very end.\n    req,\n    showHiddenFields,\n    siblingDoc,\n    triggerAccessControl: false, // TODO: Enable this to support access control\n    triggerHooks: false, // TODO: Enable this to support hooks\n  })\n}\n"],"names":["afterReadTraverseFields","recurseNestedFields","context","currentDepth","data","depth","fields","findMany","flattenLocales","overrideAccess","populationPromises","promises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","fieldPromises","global","locale","triggerAccessControl","triggerHooks"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,uBAAuB,QAAQ,oBAAmB;AAwB3D,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,OAAO,EACPC,eAAe,CAAC,EAChBC,IAAI,EACJC,KAAK,EACLC,MAAM,EACNC,QAAQ,EACRC,cAAc,EACdC,iBAAiB,KAAK,EACtBC,kBAAkB,EAClBC,QAAQ,EACRC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACe;IACzBd,wBAAwB;QACtBe,YAAY;QACZb;QACAC;QACAE;QACAW,KAAKZ;QACLa,gBAAgBL,IAAIK,cAAc;QAClCC,eAAeP;QACfL;QACAC;QACAC;QACAW,QAAQ;QACRC,QAAQR,IAAIQ,MAAM;QAClBX;QACAC;QACAE;QACAC;QACAC;QACAO,sBAAsB;QACtBC,cAAc;IAChB;AACF,EAAC"}
+{"version":3,"sources":["../../src/populate/recurseNestedFields.ts"],"sourcesContent":["import type { RequestContext } from 'payload'\nimport type { Field, PayloadRequestWithData } from 'payload/types'\n\nimport { afterReadTraverseFields } from 'payload/utilities'\n\nimport type { PopulationPromise } from '../field/features/types.js'\n\ntype NestedRichTextFieldsArgs = {\n  context: RequestContext\n  currentDepth?: number\n  data: unknown\n  depth: number\n  draft: boolean\n  /**\n   * This maps all the population promises to the node types\n   */\n  editorPopulationPromises: Map<string, Array<PopulationPromise>>\n  /**\n   * fieldPromises are used for things like field hooks. They should be awaited before awaiting populationPromises\n   */\n  fieldPromises: Promise<void>[]\n  fields: Field[]\n  findMany: boolean\n  flattenLocales: boolean\n  overrideAccess: boolean\n  populationPromises: Promise<void>[]\n  req: PayloadRequestWithData\n  showHiddenFields: boolean\n  siblingDoc: Record<string, unknown>\n}\n\nexport const recurseNestedFields = ({\n  context,\n  currentDepth = 0,\n  data,\n  depth,\n  draft,\n  fieldPromises,\n  fields,\n  findMany,\n  flattenLocales,\n  overrideAccess = false,\n  populationPromises,\n  req,\n  showHiddenFields,\n  siblingDoc,\n}: NestedRichTextFieldsArgs): void => {\n  afterReadTraverseFields({\n    collection: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    context,\n    currentDepth,\n    depth,\n    doc: data as any, // Looks like it's only needed for hooks and access control, so doesn't matter what we pass here right now\n    draft,\n    fallbackLocale: req.fallbackLocale,\n    fieldPromises,\n    fields,\n    findMany,\n    flattenLocales,\n    global: null, // Pass from core? This is only needed for hooks, so we can leave this null for now\n    locale: req.locale,\n    overrideAccess,\n    populationPromises, // This is not the same as populationPromises passed into this recurseNestedFields. These are just promises resolved at the very end.\n    req,\n    showHiddenFields,\n    siblingDoc,\n    //triggerAccessControl: false, // TODO: Enable this to support access control\n    //triggerHooks: false, // TODO: Enable this to support hooks\n  })\n}\n"],"names":["afterReadTraverseFields","recurseNestedFields","context","currentDepth","data","depth","draft","fieldPromises","fields","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","global","locale"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,uBAAuB,QAAQ,oBAAmB;AA4B3D,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,OAAO,EACPC,eAAe,CAAC,EAChBC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,aAAa,EACbC,MAAM,EACNC,QAAQ,EACRC,cAAc,EACdC,iBAAiB,KAAK,EACtBC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACe;IACzBf,wBAAwB;QACtBgB,YAAY;QACZd;QACAC;QACAE;QACAY,KAAKb;QACLE;QACAY,gBAAgBL,IAAIK,cAAc;QAClCX;QACAC;QACAC;QACAC;QACAS,QAAQ;QACRC,QAAQP,IAAIO,MAAM;QAClBT;QACAC;QACAC;QACAC;QACAC;IAGF;AACF,EAAC"}

package/dist/scss/app.scss

@@ -1,4 +1,3 @@
-@import 'fonts';
 @import 'styles';
 @import './toastify.scss';
 @import './colors.scss';
@@ -20,9 +19,9 @@
   --theme-overlay: rgba(5, 5, 5, 0.5);
   --theme-baseline: #{$baseline-px};
   --theme-baseline-body-size: #{$baseline-body-size};
-  --font-body: 'Suisse Intl', system-ui;
+  --font-body: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
+    sans-serif;
   --font-mono: monospace;
-  --font-serif: 'Merriweather', serif;
 
   --style-radius-s: #{$style-radius-s};
   --style-radius-m: #{$style-radius-m};

package/dist/scss/vars.scss

@@ -21,13 +21,6 @@ $baseline: math.div($baseline-px, $baseline-body-size) + rem;
   @return (math.div($baseline-px, $baseline-body-size) * $multiplier) + rem;
 }
 
-//////////////////////////////
-// FONTS (DEPRECATED. DO NOT USE. PREFER CSS VARIABLES)
-//////////////////////////////
-
-$font-body: 'Suisse Intl' !default;
-$font-mono: monospace !default;
-
 //////////////////////////////
 // COLORS (DEPRECATED. DO NOT USE. PREFER CSS VARIABLES)
 //////////////////////////////

package/dist/types.d.ts

@@ -1,20 +1,59 @@
-import type { SerializedEditorState } from 'lexical';
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical';
 import type { FieldPermissions } from 'payload/auth';
-import type { FieldTypes } from 'payload/config';
+import type { FieldTypes, SanitizedConfig } from 'payload/config';
 import type { RichTextAdapter, RichTextFieldProps } from 'payload/types';
 import type React from 'react';
 import type { FeatureProviderServer } from './field/features/types.js';
 import type { SanitizedServerEditorConfig } from './field/lexical/config/types.js';
+export type LexicalFieldAdminProps = {
+    /**
+     * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false
+     */
+    hideGutter?: boolean;
+};
 export type LexicalEditorProps = {
-    features?: (({ defaultFeatures, }: {
-        defaultFeatures: FeatureProviderServer<unknown, unknown>[];
-    }) => FeatureProviderServer<unknown, unknown>[]) | FeatureProviderServer<unknown, unknown>[];
+    admin?: LexicalFieldAdminProps;
+    features?: (({ defaultFeatures, rootFeatures, }: {
+        /**
+         * This opinionated array contains all "recommended" default features.
+         *
+         * @Example
+         *
+         * ```ts
+         *  editor: lexicalEditor({
+         *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],
+         *  })
+         *  ```
+         */
+        defaultFeatures: FeatureProviderServer<any, any>[];
+        /**
+         * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).
+         * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty
+         *
+         * @Example
+         *
+         * ```ts
+         *  editor: lexicalEditor({
+         *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],
+         *  })
+         *  ```
+         */
+        rootFeatures: FeatureProviderServer<any, any>[];
+    }) => FeatureProviderServer<any, any>[]) | FeatureProviderServer<any, any>[];
     lexical?: LexicalEditorConfig;
 };
 export type LexicalRichTextAdapter = RichTextAdapter<SerializedEditorState, AdapterProps, any> & {
     editorConfig: SanitizedServerEditorConfig;
+    features: FeatureProviderServer<any, any>[];
 };
+export type LexicalRichTextAdapterProvider = 
+/**
+ * This is being called during the payload sanitization process
+ */
+({ config, isRoot, }: {
+    config: SanitizedConfig;
+    isRoot?: boolean;
+}) => Promise<LexicalRichTextAdapter>;
 export type FieldProps = RichTextFieldProps<SerializedEditorState, AdapterProps, AdapterProps> & {
     fieldTypes: FieldTypes;
     indexPath: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAElF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EACL,CAAC,CAAC,EACA,eAAe,GAChB,EAAE;QACD,eAAe,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;KAC3D,KAAK,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,GAChD,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAA;IAC7C,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAGD,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC,qBAAqB,EAAE,YAAY,EAAE,GAAG,CAAC,GAAG;IAC/F,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,qBAAqB,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG;IAC/F,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,gBAAgB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,eAAe,EAAE,KAAK,CAAC,SAAS,CAAA;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAElF,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,sBAAsB,CAAA;IAC9B,QAAQ,CAAC,EACL,CAAC,CAAC,EACA,eAAe,EACf,YAAY,GACb,EAAE;QACD;;;;;;;;;;WAUG;QACH,eAAe,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;QAClD;;;;;;;;;;;WAWG;QACH,YAAY,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;KAChD,KAAK,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GACxC,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;IACrC,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC,qBAAqB,EAAE,YAAY,EAAE,GAAG,CAAC,GAAG;IAC/F,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;CAC5C,CAAA;AAED,MAAM,MAAM,8BAA8B;AACxC;;GAEG;AACH,CAAC,EACC,MAAM,EACN,MAAM,GACP,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAA;AAEvC,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,qBAAqB,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG;IAC/F,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,gBAAgB,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,eAAe,EAAE,KAAK,CAAC,SAAS,CAAA;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\nimport type { FieldPermissions } from 'payload/auth'\nimport type { FieldTypes } from 'payload/config'\nimport type { RichTextAdapter, RichTextFieldProps } from 'payload/types'\nimport type React from 'react'\n\nimport type { FeatureProviderServer } from './field/features/types.js'\nimport type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'\n\nexport type LexicalEditorProps = {\n  features?:\n    | (({\n        defaultFeatures,\n      }: {\n        defaultFeatures: FeatureProviderServer<unknown, unknown>[]\n      }) => FeatureProviderServer<unknown, unknown>[])\n    | FeatureProviderServer<unknown, unknown>[]\n  lexical?: LexicalEditorConfig\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\nexport type LexicalRichTextAdapter = RichTextAdapter<SerializedEditorState, AdapterProps, any> & {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type FieldProps = RichTextFieldProps<SerializedEditorState, AdapterProps, AdapterProps> & {\n  fieldTypes: FieldTypes\n  indexPath: string\n  path?: string\n  permissions: FieldPermissions\n}\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  ClientComponent: React.ReactNode\n  key: string\n  order: number\n}\n"],"names":[],"rangeMappings":"","mappings":"AAqCA,WAIC"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig, SerializedEditorState } from 'lexical'\nimport type { FieldPermissions } from 'payload/auth'\nimport type { FieldTypes, SanitizedConfig } from 'payload/config'\nimport type { RichTextAdapter, RichTextFieldProps } from 'payload/types'\nimport type React from 'react'\n\nimport type { FeatureProviderServer } from './field/features/types.js'\nimport type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'\n\nexport type LexicalFieldAdminProps = {\n  /**\n   * Controls if the gutter (padding to the left & gray vertical line) should be hidden. @default false\n   */\n  hideGutter?: boolean\n}\n\nexport type LexicalEditorProps = {\n  admin?: LexicalFieldAdminProps\n  features?:\n    | (({\n        defaultFeatures,\n        rootFeatures,\n      }: {\n        /**\n         * This opinionated array contains all \"recommended\" default features.\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ defaultFeatures }) => [...defaultFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        defaultFeatures: FeatureProviderServer<any, any>[]\n        /**\n         * This array contains all features that are enabled in the root richText editor (the one defined in the payload.config.ts).\n         * If this field is the root richText editor, or if the root richText editor is not a lexical editor, this array will be empty\n         *\n         * @Example\n         *\n         * ```ts\n         *  editor: lexicalEditor({\n         *    features: ({ rootFeatures }) => [...rootFeatures, FixedToolbarFeature()],\n         *  })\n         *  ```\n         */\n        rootFeatures: FeatureProviderServer<any, any>[]\n      }) => FeatureProviderServer<any, any>[])\n    | FeatureProviderServer<any, any>[]\n  lexical?: LexicalEditorConfig\n}\n\nexport type LexicalRichTextAdapter = RichTextAdapter<SerializedEditorState, AdapterProps, any> & {\n  editorConfig: SanitizedServerEditorConfig\n  features: FeatureProviderServer<any, any>[]\n}\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({\n    config,\n    isRoot,\n  }: {\n    config: SanitizedConfig\n    isRoot?: boolean\n  }) => Promise<LexicalRichTextAdapter>\n\nexport type FieldProps = RichTextFieldProps<SerializedEditorState, AdapterProps, AdapterProps> & {\n  fieldTypes: FieldTypes\n  indexPath: string\n  path?: string\n  permissions: FieldPermissions\n}\n\nexport type AdapterProps = {\n  editorConfig: SanitizedServerEditorConfig\n}\n\nexport type GeneratedFeatureProviderComponent = {\n  ClientComponent: React.ReactNode\n  key: string\n  order: number\n}\n"],"names":[],"rangeMappings":"","mappings":"AAiFA,WAIC"}

package/dist/useLexicalFeature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLexicalFeature.d.ts","sourceRoot":"","sources":["../src/useLexicalFeature.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEtE,eAAO,MAAM,iBAAiB,mCAChB,MAAM,WACT,sBAAsB,kBAAkB,CAAC,SAKnD,CAAA"}
+{"version":3,"file":"useLexicalFeature.d.ts","sourceRoot":"","sources":["../src/useLexicalFeature.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEtE,eAAO,MAAM,iBAAiB,mCAChB,MAAM,WACT,sBAAsB,kBAAkB,CAAC,SAUnD,CAAA"}

package/dist/useLexicalFeature.js

@@ -1,8 +1,13 @@
 'use client';
+import { useTableCell } from '@payloadcms/ui/elements/Table';
 import { useFieldProps } from '@payloadcms/ui/forms/FieldPropsProvider';
 import { useAddClientFunction } from '@payloadcms/ui/providers/ClientFunction';
 export const useLexicalFeature = (featureKey, feature)=>{
-    const { schemaPath } = useFieldProps();
+    const { schemaPath: schemaPathFromFieldProps } = useFieldProps();
+    const tableCell = useTableCell();
+    const schemaPathFromCellProps = tableCell?.cellProps?.schemaPath;
+    const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.
+    ;
     useAddClientFunction(`lexicalFeature.${schemaPath}.${featureKey}`, feature);
 };