@payloadcms/richtext-lexical 3.0.0-alpha.64 → 3.0.0-alpha.66

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 { AdapterProps, LexicalEditorProps, LexicalRichTextAdapterProvider } 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 { 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 }) => {\n    let resolvedFeatureMap: ResolvedServerFeatureMap = null\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      }\n\n      finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)\n\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 = await loadFeatures({\n        config,\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      editorConfig: finalSanitizedEditorConfig,\n      generateComponentMap: getGenerateComponentMap({\n        resolvedFeatureMap,\n      }),\n      generateSchemaMap: getGenerateSchemaMap({\n        resolvedFeatureMap,\n      }),\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        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            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 {\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'\n\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'\nexport { HeadingFeature } from './field/features/heading/feature.server.js'\n\nexport { HorizontalRuleFeature } from './field/features/horizontalrule/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 { 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  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 {\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} 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","loadFeatures","sanitizeServerEditorConfig","sanitizeServerFeatures","cloneDeep","getGenerateComponentMap","getGenerateSchemaMap","populateLexicalPopulationPromises","richTextValidateHOC","defaultSanitizedServerEditorConfig","lexicalEditor","props","config","resolvedFeatureMap","finalSanitizedEditorConfig","features","lexical","defaultFeatures","unSanitizedEditorConfig","CellComponent","Component","toMergeIntoProps","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","fieldPromises","findMany","flattenLocales","overrideAccess","req","showHiddenFields","siblingDoc","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","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","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","EditorConfigProvider","useEditorConfigContext","sanitizeClientEditorConfig","sanitizeClientFeatures","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","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":"AAGA,SAASA,eAAe,QAAQ,0CAAyC;AACzE,SAASC,0BAA0B,QAAQ,oBAAmB;AAM9D,SAASC,YAAY,QAAQ,kBAAiB;AAC9C,SAASC,aAAa,QAAQ,mBAAkB;AAChD,SACEC,mBAAmB,EACnBC,qBAAqB,QAChB,2CAA0C;AACjD,SAASC,YAAY,QAAQ,0CAAyC;AACtE,SACEC,0BAA0B,EAC1BC,sBAAsB,QACjB,4CAA2C;AAClD,SAASC,SAAS,QAAQ,qCAAoC;AAC9D,SAASC,uBAAuB,QAAQ,4BAA2B;AACnE,SAASC,oBAAoB,QAAQ,yBAAwB;AAC7D,SAASC,iCAAiC,QAAQ,kDAAiD;AACnG,SAASC,mBAAmB,QAAQ,sBAAqB;AAEzD,IAAIC,qCAAkE;AAEtE,OAAO,SAASC,cAAcC,KAA0B;IACtD,OAAO,OAAO,EAAEC,MAAM,EAAE;QACtB,IAAIC,qBAA+C;QAEnD,IAAIC,0BAAwD,kBAAkB;;QAC9E,IAAI,CAACH,SAAU,CAACA,MAAMI,QAAQ,IAAI,CAACJ,MAAMK,OAAO,EAAG;YACjD,IAAI,CAACP,oCAAoC;gBACvCA,qCAAqC,MAAMP,2BACzCH,qBACAa;YAEJ;YAEAE,6BAA6BV,UAAUK;YAEvCI,qBAAqBC,2BAA2BD,kBAAkB;QACpE,OAAO;YACL,IAAIE,WACFJ,MAAMI,QAAQ,IAAI,OAAOJ,MAAMI,QAAQ,KAAK,aACxCJ,MAAMI,QAAQ,CAAC;gBAAEE,iBAAiBb,UAAUJ;YAAuB,KAClEW,MAAMI,QAAQ;YACrB,IAAI,CAACA,UAAU;gBACbA,WAAWX,UAAUJ;YACvB;YAEA,MAAMgB,UAA+BL,MAAMK,OAAO;YAElDH,qBAAqB,MAAMZ,aAAa;gBACtCW;gBACAM,yBAAyB;oBACvBH;oBACAC,SAASA,UAAUA,UAAUjB,oBAAoBiB,OAAO;gBAC1D;YACF;YAEAF,6BAA6B;gBAC3BC,UAAUZ,uBAAuBU;gBACjCG,SAASA,UAAUA,UAAUjB,oBAAoBiB,OAAO;gBACxDH;YACF;QACF;QAEA,OAAO;YACLM,eAAexB,gBAAgB;gBAC7ByB,WAAWvB;gBACXwB,kBAAkB;oBAAEC,qBAAqBR,2BAA2BE,OAAO;gBAAC;YAC9E;YACAO,gBAAgB5B,gBAAgB;gBAC9ByB,WAAWtB;gBACXuB,kBAAkB;oBAAEC,qBAAqBR,2BAA2BE,OAAO;gBAAC;YAC9E;YACAQ,cAAcV;YACdW,sBAAsBpB,wBAAwB;gBAC5CQ;YACF;YACAa,mBAAmBpB,qBAAqB;gBACtCO;YACF;YACA;;;;;;QAME,GACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ee,GAAG;;;;;;;;;;;MAWlB,GACAc,cAAc,CAAC,EACbC,sBAAsB,EACtBhB,MAAM,EACNiB,KAAK,EACLC,wBAAwB,EACxBC,UAAU,EACX;gBACC,IAAIJ,eAA4B;oBAC9B,iJAAiJ;oBACjJ,2BAA2B;oBAC3B,8BAA8B;oBAC9B,yHAAyH;oBACzHK,MAAMpC,2BAA2B,UAAUmC;oBAC3CE,YAAY;wBACVC,MAAM;4BACJF,MAAM;4BACNG,sBAAsB;4BACtBF,YAAY;gCACVD,MAAM;oCACJA,MAAM;gCACR;gCACAI,UAAU;oCACRJ,MAAM;oCACNK,OAAO;wCACLL,MAAM;wCACNG,sBAAsB;wCACtBF,YAAY;4CACVD,MAAM;gDACJA,MAAM;4CACR;4CACAM,SAAS;gDACPN,MAAM;4CACR;wCACF;wCACAO,UAAU;4CAAC;4CAAQ;yCAAU;oCAC/B;gCACF;gCACAC,WAAW;oCACTC,OAAO;wCACL;4CACEC,MAAM;gDAAC;gDAAO;6CAAM;wCACtB;wCACA;4CACEV,MAAM;wCACR;qCACD;gCACH;gCACAW,QAAQ;oCACNX,MAAM;oCACNU,MAAM;wCAAC;wCAAQ;wCAAS;wCAAU;wCAAS;wCAAO;wCAAW;qCAAG;gCAClE;gCACAE,QAAQ;oCACNZ,MAAM;gCACR;gCACAM,SAAS;oCACPN,MAAM;gCACR;4BACF;4BACAO,UAAU;gCAAC;gCAAY;gCAAa;gCAAU;gCAAU;gCAAQ;6BAAU;wBAC5E;oBACF;oBACAA,UAAU;wBAAC;qBAAO;gBACpB;gBACA,KAAK,MAAMM,sBAAsB/B,2BAA2BC,QAAQ,CAAC+B,cAAc,CAChFC,mBAAmB,CAAE;oBACtBpB,eAAekB,mBAAmB;wBAChCjB;wBACAhB;wBACAoC,eAAerB;wBACfE;wBACAC;wBACAC;oBACF;gBACF;gBAEA,OAAOJ;YACT;YACAsB,oBAAmB,EACjBC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLvB,KAAK,EACLwB,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,cAAc,EACdP,kBAAkB,EAClBQ,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACX;gBACC,0FAA0F;gBAC1F,IAAI7C,4BAA4BC,UAAUkC,oBAAoBW,MAAM;oBAClErD,kCAAkC;wBAChC2C;wBACAC;wBACAC;wBACAS,0BAA0B/C,2BAA2BC,QAAQ,CAACkC,kBAAkB;wBAChFpB;wBACAwB;wBACAC;wBACAC;wBACAC;wBACAP;wBACAQ;wBACAC;wBACAC;oBACF;gBACF;YACF;YACAG,UAAUtD,oBAAoB;gBAC5BgB,cAAcV;YAChB;QACF;IACF;AACF;AAEA,SAASiD,YAAY,QAAQ,2CAA0C;AACvE,SAASC,iBAAiB,QAAQ,gDAA+C;AACjF,SACEC,aAAa,QAGR,4CAA2C;AAClD,SACEC,gBAAgB,EAChBC,YAAY,EAEZC,SAAS,QAEJ,8CAA6C;AAEpD,SAASC,8BAA8B,QAAQ,4EAA2E;AAC1H,SAASC,sBAAsB,QAAQ,qEAAoE;AAC3G,SAASC,sBAAsB,QAAQ,qEAAoE;AAE3G,SAASC,iBAAiB,QAAQ,gEAA+D;AACjG,SAASC,qBAAqB,QAAQ,kEAAiE;AACvG,SACEC,yBAAyB,EACzBC,oBAAoB,QACf,sDAAqD;AAE5D,SACEC,oBAAoB,QAEf,qDAAoD;AAC3D,SACEC,yBAAyB,EACzBC,WAAW,QACN,kDAAiD;AACxD,SAASC,qBAAqB,QAAQ,4CAA2C;AACjF,SAASC,mBAAmB,QAAQ,wDAAuD;AAC3F,SAASC,eAAe,QAAQ,oDAAmD;AACnF,SAASC,WAAW,QAAQ,iDAAgD;AAE5E,SAASC,sBAAsBC,wBAAwB,QAAQ,iEAAgE;AAC/H,SAASC,iBAAiB,QAAQ,uDAAsD;AACxF,SAASC,aAAa,QAAQ,mDAAkD;AAChF,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,cAAc,QAAQ,6CAA4C;AAE3E,SAASC,qBAAqB,QAAQ,oDAAmD;AACzF,SAASC,aAAa,QAAQ,4CAA2C;AAEzE,SAASC,WAAW,QAAqC,0CAAyC;AAClG,SACEC,mBAAmB,EACnBC,eAAe,EACfC,YAAY,QACP,8CAA6C;AACpD,SACEC,eAAe,EACfC,WAAW,EACXC,QAAQ,EACRC,mBAAmB,QACd,0CAAyC;AAMhD,SAASC,gBAAgB,QAAQ,qDAAoD;AACrF,SAASC,kBAAkB,QAAQ,uDAAsD;AACzF,SAASC,oBAAoB,QAAQ,yDAAwD;AAC7F,SAASC,6BAA6B,QAAQ,uEAAsE;AACpH,SAASC,wBAAwB,QAAQ,sFAAqF;AAC9H,SAASC,qBAAqB,QAAQ,mFAAkF;AACxH,SAASC,oBAAoB,QAAQ,kFAAiF;AACtH,SAASC,kBAAkB,QAAQ,gFAA+E;AAClH,SAASC,sBAAsB,QAAQ,oFAAmF;AAC1H,SAASC,yBAAyB,QAAQ,uFAAsF;AAChI,SAASC,0BAA0B,QAAQ,wFAAuF;AAClI,SAASC,qBAAqB,QAAQ,mFAAkF;AACxH,SAASC,2BAA2B,QAAQ,yFAAwF;AAEpI,SAASC,oBAAoB,QAAQ,kFAAiF;AACtH,SAASC,sBAAsB,QAAQ,4EAA2E;AAClH,SACEC,0BAA0B,EAC1BC,qBAAqB,QAChB,gEAA+D;AAMtE,SAASC,qBAAqB,QAAQ,+DAA8D;AACpG,SAASC,gBAAgB,QAAQ,+CAA8C;AAC/E,SAASC,mBAAmB,QAAQ,kDAAiD;AACrF,SACEC,uBAAuB,EACvBC,mBAAmB,EAEnBC,gBAAgB,QAEX,0DAAyD;AAChE,SAASC,UAAU,QAAQ,oCAAmC;AAwB9D,SAASC,aAAa,QAAQ,4CAA2C;AAIzE,SACEC,iBAAiB,EACjBC,aAAa,EAGbC,UAAU,QACL,8CAA6C;AACpD,SACEC,oBAAoB,EACpBC,sBAAsB,QACjB,wDAAuD;AAC9D,SACEC,0BAA0B,EAC1BC,sBAAsB,QACjB,4CAA2C;AAClD,SACEtI,mBAAmB,EACnBC,qBAAqB,EACrBsI,0BAA0B,QACrB,2CAA0C;AACjD,SACErI,YAAY,EACZsI,6BAA6B,QACxB,0CAAyC;AAChD,SACErI,0BAA0B,EAC1BC,sBAAsB,QACjB,4CAA2C;AAQlD,SAASqI,eAAe,QAAQ,iCAAgC;AAMhE,SAASC,yBAAyB,QAAQ,wEAAuE;AAGjH,SACEC,cAAc,EACdC,eAAe,QACV,wEAAuE;AAC9E,SAASC,WAAW,QAAQ,qCAAoC;AAChE,SAASxI,SAAS,QAAQ,qCAAoC;AAC9D,SAASyI,eAAe,QAAQ,2CAA0C;AAC1E,SAASC,eAAe,QAAQ,2CAA0C;AAC1E,SAASC,aAAa,QAAQ,iCAAgC;AAC9D,SAASC,SAAS,QAAQ,qCAAoC;AAC9D,SAASC,WAAW,QAAQ,uCAAsC;AAClE,SAASC,eAAe,QAAQ,oDAAmD;AACnF,SACEC,qBAAqB,EACrBC,iBAAiB,EACjBC,sBAAsB,EACtBC,sBAAsB,EACtBC,iBAAiB,EACjBC,SAAS,EACTC,kBAAkB,EAClBC,UAAU,EACVC,SAAS,EACTC,iBAAiB,EACjBC,mBAAmB,EACnBC,iBAAiB,QACZ,sCAAqC;AAC5C,SAASC,KAAK,EAAEC,OAAO,QAAQ,iCAAgC;AAC/D,SAASC,IAAI,QAAQ,gCAA+B;AACpD,SAASC,uBAAuB,QAAQ,mDAAkD;AAC1F,SAASC,oCAAoC,QAAQ,gEAA+D;AACpH,SACEC,oBAAoB,EACpBC,oBAAoB,EACpBC,qBAAqB,EACrBC,kBAAkB,QACb,iCAAgC;AACvC,SAASC,WAAW,EAAEC,WAAW,QAAQ,+BAA8B;AACvE,SAASC,oBAAoB,QAAQ,6BAA4B"}

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;AAED,eAAO,MAAM,sBAAsB,EAAE,qBAkBpC,CAAA"}

package/dist/populate/defaultValue.js

@@ -18,6 +18,7 @@ export const defaultRichTextValue = {
                 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\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","textFormat","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;gBACRC,YAAY;gBACZH,SAAS;YACX;SACD;QACDC,WAAW;QACXL,QAAQ;QACRM,QAAQ;QACRF,SAAS;IACX;AACF,EAAC;AAED,OAAO,MAAMI,yBAAgD;IAC3DZ,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"}

package/dist/populate/populate.d.ts

@@ -1,5 +1,5 @@
 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 = {
@@ -9,13 +9,13 @@ type Arguments = {
     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'> & {
     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;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,sBAAsB,CAAA;IAC3B,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,GAAG,MAAM,CAAA;CACpB,KAAG,QAAQ,IAAI,CAsBf,CAAA"}

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 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: PayloadRequestWithData\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: number | 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"}

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, 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,uLAc3C,IAAI,SA8BN,CAAA"}

package/dist/populate/populateLexicalPopulationPromises.js

@@ -0,0 +1,35 @@
+import { recurseNodes } from '../forEachNodeRecursively.js';
+/**
+ * Appends all new populationPromises to the populationPromises prop
+ */ export const populateLexicalPopulationPromises = ({ context, currentDepth, depth, 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,
+                        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  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            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","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,wBAAwB,EACxBC,KAAK,EACLC,aAAa,EACbC,QAAQ,EACRC,cAAc,EACdC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACL;IACL,IAAIV,SAAS,KAAKD,eAAeC,OAAO;QACtC;IACF;IAEAJ,aAAa;QACXe,UAAU,CAACC;YACT,IAAIX,0BAA0BY,IAAID,KAAKE,IAAI,GAAG;gBAC5C,KAAK,MAAMC,WAAWd,yBAAyBe,GAAG,CAACJ,KAAKE,IAAI,EAAG;oBAC7DC,QAAQ;wBACNjB;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,5 +1,5 @@
 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;
@@ -10,16 +10,19 @@ type NestedRichTextFieldsArgs = {
      * 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, 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;;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,oKAc7B,wBAAwB,KAAG,IAsB7B,CAAA"}

package/dist/populate/recurseNestedFields.js

@@ -1,5 +1,5 @@
 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, fieldPromises, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, req, showHiddenFields, siblingDoc })=>{
     afterReadTraverseFields({
         collection: null,
         context,
@@ -7,7 +7,7 @@ export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, fi
         depth,
         doc: data,
         fallbackLocale: req.fallbackLocale,
-        fieldPromises: promises,
+        fieldPromises,
         fields,
         findMany,
         flattenLocales,
@@ -17,9 +17,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  /**\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  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    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","fieldPromises","fields","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","collection","doc","fallbackLocale","global","locale"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,uBAAuB,QAAQ,oBAAmB;AA2B3D,OAAO,MAAMC,sBAAsB,CAAC,EAClCC,OAAO,EACPC,eAAe,CAAC,EAChBC,IAAI,EACJC,KAAK,EACLC,aAAa,EACbC,MAAM,EACNC,QAAQ,EACRC,cAAc,EACdC,iBAAiB,KAAK,EACtBC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACe;IACzBd,wBAAwB;QACtBe,YAAY;QACZb;QACAC;QACAE;QACAW,KAAKZ;QACLa,gBAAgBL,IAAIK,cAAc;QAClCX;QACAC;QACAC;QACAC;QACAS,QAAQ;QACRC,QAAQP,IAAIO,MAAM;QAClBT;QACAC;QACAC;QACAC;QACAC;IAGF;AACF,EAAC"}

package/dist/types.d.ts

@@ -1,20 +1,26 @@
-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 LexicalEditorProps = {
     features?: (({ defaultFeatures, }: {
-        defaultFeatures: FeatureProviderServer<unknown, unknown>[];
-    }) => FeatureProviderServer<unknown, unknown>[]) | FeatureProviderServer<unknown, unknown>[];
+        defaultFeatures: FeatureProviderServer<any, any>[];
+    }) => FeatureProviderServer<any, any>[]) | FeatureProviderServer<any, any>[];
     lexical?: LexicalEditorConfig;
 };
 export type LexicalRichTextAdapter = RichTextAdapter<SerializedEditorState, AdapterProps, any> & {
     editorConfig: SanitizedServerEditorConfig;
 };
+export type LexicalRichTextAdapterProvider = 
+/**
+ * This is being called during the payload sanitization process
+ */
+({ config }: {
+    config: SanitizedConfig;
+}) => 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,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EACL,CAAC,CAAC,EACA,eAAe,GAChB,EAAE;QACD,eAAe,EAAE,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAA;KACnD,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;CAC1C,CAAA;AAED,MAAM,MAAM,8BAA8B;AACxC;;GAEG;AACH,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAA;AAE9E,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 LexicalEditorProps = {\n  features?:\n    | (({\n        defaultFeatures,\n      }: {\n        defaultFeatures: 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}\n\nexport type LexicalRichTextAdapterProvider =\n  /**\n   * This is being called during the payload sanitization process\n   */\n  ({ config }: { config: SanitizedConfig }) => 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":"AAyCA,WAIC"}

package/dist/validate/index.d.ts

@@ -3,5 +3,5 @@ import type { RichTextField, Validate } from 'payload/types';
 import type { SanitizedServerEditorConfig } from '../field/lexical/config/types.js';
 export declare const richTextValidateHOC: ({ editorConfig, }: {
     editorConfig: SanitizedServerEditorConfig;
-}) => Validate<SerializedEditorState<import("lexical/LexicalNode.js").SerializedLexicalNode>, unknown, unknown, RichTextField>;
+}) => Validate<SerializedEditorState<import("lexical").SerializedLexicalNode>, unknown, unknown, RichTextField>;
 //# sourceMappingURL=index.d.ts.map

package/dist/validate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validate/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAKnF,eAAO,MAAM,mBAAmB,sBAE7B;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,6HAyCA,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validate/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE5D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAKnF,eAAO,MAAM,mBAAmB,sBAE7B;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,8GAyCA,CAAA"}

package/package.json

@@ -1,39 +1,55 @@
 {
   "name": "@payloadcms/richtext-lexical",
-  "version": "3.0.0-alpha.64",
+  "version": "3.0.0-alpha.66",
   "description": "The officially supported Lexical richtext adapter for Payload",
+  "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/payloadcms/payload.git",
     "directory": "packages/richtext-lexical"
   },
   "license": "MIT",
-  "homepage": "https://payloadcms.com",
   "author": "Payload CMS, Inc.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/exports/*.js",
+      "require": "./dist/exports/*.js",
+      "types": "./dist/exports/*.d.ts"
+    }
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "type": "module",
+  "files": [
+    "dist",
+    "components.js",
+    "components.d.ts"
+  ],
   "dependencies": {
     "@faceless-ui/modal": "2.0.2",
-    "@lexical/headless": "0.13.1",
-    "@lexical/link": "0.13.1",
-    "@lexical/list": "0.13.1",
-    "@lexical/mark": "0.13.1",
-    "@lexical/markdown": "0.13.1",
-    "@lexical/react": "0.13.1",
-    "@lexical/rich-text": "0.13.1",
-    "@lexical/selection": "0.13.1",
-    "@lexical/utils": "0.13.1",
+    "@lexical/headless": "0.14.5",
+    "@lexical/link": "0.14.5",
+    "@lexical/list": "0.14.5",
+    "@lexical/mark": "0.14.5",
+    "@lexical/markdown": "0.14.5",
+    "@lexical/react": "0.14.5",
+    "@lexical/rich-text": "0.14.5",
+    "@lexical/selection": "0.14.5",
+    "@lexical/utils": "0.14.5",
+    "@types/uuid": "^9.0.8",
     "bson-objectid": "2.0.4",
     "classnames": "^2.3.2",
     "deep-equal": "2.2.3",
     "json-schema": "^0.4.0",
-    "lexical": "0.13.1",
+    "lexical": "0.14.5",
     "lodash": "4.17.21",
-    "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "react-error-boundary": "4.0.12",
-    "ts-essentials": "7.0.3"
+    "react-error-boundary": "4.0.13",
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@types/json-schema": "7.0.15",
@@ -41,45 +57,30 @@
     "@types/react": "18.2.74",
     "@types/react-dom": "18.2.24",
     "@payloadcms/eslint-config": "1.1.1",
-    "payload": "3.0.0-alpha.64",
-    "@payloadcms/translations": "3.0.0-alpha.64",
-    "@payloadcms/ui": "3.0.0-alpha.64",
-    "@payloadcms/next": "3.0.0-alpha.64"
+    "@payloadcms/next": "3.0.0-alpha.66",
+    "@payloadcms/translations": "3.0.0-alpha.66",
+    "@payloadcms/ui": "3.0.0-alpha.66",
+    "payload": "3.0.0-alpha.66"
   },
   "peerDependencies": {
-    "@payloadcms/translations": "3.0.0-alpha.64",
-    "@payloadcms/ui": "3.0.0-alpha.64",
-    "@payloadcms/next": "3.0.0-alpha.64",
-    "payload": "3.0.0-alpha.64"
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "@payloadcms/next": "3.0.0-alpha.66",
+    "payload": "3.0.0-alpha.66",
+    "@payloadcms/translations": "3.0.0-alpha.66",
+    "@payloadcms/ui": "3.0.0-alpha.66"
   },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./*": {
-      "import": "./dist/exports/*.js",
-      "require": "./dist/exports/*.js",
-      "types": "./dist/exports/*.d.ts"
-    }
+  "engines": {
+    "node": ">=18.20.2"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "engines": {
-    "node": ">=18.20.2"
-  },
-  "files": [
-    "dist",
-    "components.js",
-    "components.d.ts"
-  ],
   "scripts": {
     "build": "pnpm copyfiles && pnpm build:swc && pnpm build:types",
+    "build:clean": "find . \\( -type d \\( -name build -o -name dist -o -name .cache \\) -o -type f -name tsconfig.tsbuildinfo \\) -exec rm -rf {} + && pnpm build",
     "build:swc": "swc ./src -d ./dist --config-file .swcrc",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
-    "build:clean": "find . \\( -type d \\( -name build -o -name dist -o -name .cache \\) -o -type f -name tsconfig.tsbuildinfo \\) -exec rm -rf {} + && pnpm build",
     "clean": "rimraf {dist,*.tsbuildinfo}",
     "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/"
   }

package/dist/populate/richTextRelationshipPromise.d.ts

@@ -1,23 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { PayloadRequest, RichTextAdapter, RichTextField } from 'payload/types';
-import type { PopulationPromise } from '../field/features/types.js';
-import type { AdapterProps } from '../types.js';
-export type Args = Parameters<RichTextAdapter<SerializedEditorState, AdapterProps>['populationPromise']>[0] & {
-    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
-};
-type RecurseRichTextArgs = {
-    children: SerializedLexicalNode[];
-    currentDepth: number;
-    depth: number;
-    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
-    field: RichTextField<SerializedEditorState, AdapterProps>;
-    overrideAccess: boolean;
-    promises: Promise<void>[];
-    req: PayloadRequest;
-    showHiddenFields: boolean;
-    siblingDoc?: Record<string, unknown>;
-};
-export declare const recurseRichText: ({ children, context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, overrideAccess, populationPromises, promises, req, showHiddenFields, siblingDoc, }: RecurseRichTextArgs & Args) => void;
-export declare const richTextRelationshipPromise: ({ context, currentDepth, depth, editorPopulationPromises, field, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: Args) => Promise<void>;
-export {};
-//# sourceMappingURL=richTextRelationshipPromise.d.ts.map