@payloadcms/richtext-lexical 3.0.0-alpha.68 → 3.0.0-alpha.69

package/dist/index.js

@@ -251,13 +251,14 @@ export function lexicalEditor(props) {
                 }
                 return outputSchema;
             },
-            populationPromises ({ context, currentDepth, depth, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc }) {
+            populationPromises ({ context, currentDepth, depth, draft, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc }) {
                 // check if there are any features with nodes which have populationPromises for this field
                 if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {
                     populateLexicalPopulationPromises({
                         context,
                         currentDepth,
                         depth,
+                        draft,
                         editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,
                         field,
                         fieldPromises,
@@ -294,7 +295,7 @@ export { TreeViewFeature } from './field/features/debug/treeView/feature.server.
 export { BoldFeature } from './field/features/format/bold/feature.server.js';
 export { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js';
 export { ItalicFeature } from './field/features/format/italic/feature.server.js';
-export { inlineToolbarFormatGroupWithItems } from './field/features/format/shared/inlineToolbarFormatGroup.js';
+export { toolbarFormatGroupWithItems } from './field/features/format/shared/toolbarFormatGroup.js';
 export { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js';
 export { SubscriptFeature } from './field/features/format/subscript/feature.server.js';
 export { SuperscriptFeature } from './field/features/format/superscript/feature.server.js';
@@ -325,8 +326,11 @@ export { SlateToLexicalFeature } from './field/features/migrations/slateToLexica
 export { ParagraphFeature } from './field/features/paragraph/feature.server.js';
 export { RelationshipFeature } from './field/features/relationship/feature.server.js';
 export { $createRelationshipNode, $isRelationshipNode, RelationshipNode } from './field/features/relationship/nodes/RelationshipNode.js';
-export { inlineToolbarFeatureButtonsGroupWithItems } from './field/features/shared/inlineToolbar/featureButtonsGroup.js';
-export { inlineToolbarTextDropdownGroupWithItems } from './field/features/shared/inlineToolbar/textDropdownGroup.js';
+export { toolbarAddDropdownGroupWithItems } from './field/features/shared/toolbar/addDropdownGroup.js';
+export { toolbarFeatureButtonsGroupWithItems } from './field/features/shared/toolbar/featureButtonsGroup.js';
+export { toolbarTextDropdownGroupWithItems } from './field/features/shared/toolbar/textDropdownGroup.js';
+export { FixedToolbarFeature } from './field/features/toolbars/fixed/feature.server.js';
+export { InlineToolbarFeature } from './field/features/toolbars/inline/feature.server.js';
 export { createNode } from './field/features/typeUtilities.js';
 export { UploadFeature } from './field/features/upload/feature.server.js';
 export { $createUploadNode, $isUploadNode, UploadNode } from './field/features/upload/nodes/UploadNode.js';

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'\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\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 { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'\nexport { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'\n\nexport { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './field/features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './field/features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './field/features/converters/html/feature.server.js'\nexport {\n  consolidateHTMLConverters,\n  lexicalHTML,\n} from './field/features/converters/html/field/index.js'\nexport { 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 { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js'\n\nexport { ItalicFeature } from './field/features/format/italic/feature.server.js'\nexport { inlineToolbarFormatGroupWithItems } from './field/features/format/shared/inlineToolbarFormatGroup.js'\nexport { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './field/features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './field/features/format/underline/feature.server.js'\nexport {\n  HeadingFeature,\n  type HeadingFeatureProps,\n} from './field/features/heading/feature.server.js'\nexport { HorizontalRuleFeature } from './field/features/horizontalRule/feature.server.js'\n\nexport { IndentFeature } from './field/features/indent/feature.server.js'\nexport { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'\n\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './field/features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './field/features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './field/features/link/nodes/types.js'\nexport { ChecklistFeature } from './field/features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './field/features/lists/orderedList/feature.server.js'\nexport { UnorderedListFeature } from './field/features/lists/unorderedList/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\nexport { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'\n\nexport { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './field/features/migrations/slateToLexical/converter/index.js'\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './field/features/migrations/slateToLexical/converter/types.js'\n\nexport { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'\nexport { ParagraphFeature } from './field/features/paragraph/feature.server.js'\nexport {\n  RelationshipFeature,\n  type RelationshipFeatureProps,\n} from './field/features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './field/features/relationship/nodes/RelationshipNode.js'\nexport { inlineToolbarFeatureButtonsGroupWithItems } from './field/features/shared/inlineToolbar/featureButtonsGroup.js'\nexport { inlineToolbarTextDropdownGroupWithItems } from './field/features/shared/inlineToolbar/textDropdownGroup.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 { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nexport type { AdapterProps }\n\nexport type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from './field/lexical/plugins/toolbars/inline/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","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","createClientComponent","TestRecorderFeature","TreeViewFeature","BoldFeature","InlineCodeFeature","ItalicFeature","inlineToolbarFormatGroupWithItems","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","inlineToolbarFeatureButtonsGroupWithItems","inlineToolbarTextDropdownGroupWithItems","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","EditorConfigProvider","useEditorConfigContext","sanitizeClientEditorConfig","sanitizeClientFeatures","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","CAN_USE_DOM","getDOMRangeRect","getSelectedNode","isHTMLElement","invariant","joinClasses","createBlockNode","DETAIL_TYPE_TO_DETAIL","DOUBLE_LINE_BREAK","ELEMENT_FORMAT_TO_TYPE","ELEMENT_TYPE_TO_FORMAT","IS_ALL_FORMATTING","LTR_REGEX","NON_BREAKING_SPACE","NodeFormat","RTL_REGEX","TEXT_MODE_TO_TYPE","TEXT_TYPE_TO_FORMAT","TEXT_TYPE_TO_MODE","Point","isPoint","Rect","setFloatingElemPosition","setFloatingElemPositionForLinkEditor","addSwipeDownListener","addSwipeLeftListener","addSwipeRightListener","addSwipeUpListener","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"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\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        draft,\n        field,\n        fieldPromises,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        req,\n        showHiddenFields,\n        siblingDoc,\n      }) {\n        // check if there are any features with nodes which have populationPromises for this field\n        if (finalSanitizedEditorConfig?.features?.populationPromises?.size) {\n          populateLexicalPopulationPromises({\n            context,\n            currentDepth,\n            depth,\n            draft,\n            editorPopulationPromises: finalSanitizedEditorConfig.features.populationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            overrideAccess,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      },\n      validate: richTextValidateHOC({\n        editorConfig: finalSanitizedEditorConfig,\n      }),\n    }\n  }\n}\n\nexport { AlignFeature } from './field/features/align/feature.server.js'\nexport { BlockQuoteFeature } from './field/features/blockquote/feature.server.js'\nexport {\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 { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'\nexport { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'\n\nexport { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './field/features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './field/features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './field/features/converters/html/feature.server.js'\nexport {\n  consolidateHTMLConverters,\n  lexicalHTML,\n} from './field/features/converters/html/field/index.js'\nexport { 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 { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js'\n\nexport { ItalicFeature } from './field/features/format/italic/feature.server.js'\nexport { toolbarFormatGroupWithItems } from './field/features/format/shared/toolbarFormatGroup.js'\nexport { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './field/features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './field/features/format/underline/feature.server.js'\nexport {\n  HeadingFeature,\n  type HeadingFeatureProps,\n} from './field/features/heading/feature.server.js'\nexport { HorizontalRuleFeature } from './field/features/horizontalRule/feature.server.js'\n\nexport { IndentFeature } from './field/features/indent/feature.server.js'\nexport { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'\n\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './field/features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './field/features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './field/features/link/nodes/types.js'\nexport { ChecklistFeature } from './field/features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './field/features/lists/orderedList/feature.server.js'\nexport { UnorderedListFeature } from './field/features/lists/unorderedList/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\nexport { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'\nexport { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'\n\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './field/features/migrations/slateToLexical/converter/index.js'\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './field/features/migrations/slateToLexical/converter/types.js'\nexport { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'\n\nexport { ParagraphFeature } from './field/features/paragraph/feature.server.js'\nexport {\n  RelationshipFeature,\n  type RelationshipFeatureProps,\n} from './field/features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './field/features/relationship/nodes/RelationshipNode.js'\nexport { toolbarAddDropdownGroupWithItems } from './field/features/shared/toolbar/addDropdownGroup.js'\nexport { toolbarFeatureButtonsGroupWithItems } from './field/features/shared/toolbar/featureButtonsGroup.js'\n\nexport { toolbarTextDropdownGroupWithItems } from './field/features/shared/toolbar/textDropdownGroup.js'\nexport { FixedToolbarFeature } from './field/features/toolbars/fixed/feature.server.js'\nexport { InlineToolbarFeature } from './field/features/toolbars/inline/feature.server.js'\n\nexport type { ToolbarGroup, ToolbarGroupItem } from './field/features/toolbars/types.js'\nexport { createNode } from './field/features/typeUtilities.js'\nexport type {\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  FieldNodeHook,\n  FieldNodeHookArgs,\n  NodeValidation,\n  NodeWithHooks,\n  PopulationPromise,\n  ResolvedClientFeature,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeature,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedPlugin,\n  SanitizedServerFeatures,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from './field/features/types.js'\n\nexport { UploadFeature } from './field/features/upload/feature.server.js'\n\nexport type { UploadFeatureProps } from './field/features/upload/feature.server.js'\nexport {\n  $createUploadNode,\n  $isUploadNode,\n  type SerializedUploadNode,\n  type UploadData,\n  UploadNode,\n} from './field/features/upload/nodes/UploadNode.js'\n\nexport {\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './field/lexical/config/client/EditorConfigProvider.js'\nexport {\n  sanitizeClientEditorConfig,\n  sanitizeClientFeatures,\n} from './field/lexical/config/client/sanitize.js'\nexport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultEditorLexicalConfig,\n} from './field/lexical/config/server/default.js'\nexport {\n  loadFeatures,\n  sortFeaturesForOptimalLoading,\n} from './field/lexical/config/server/loader.js'\n\nexport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\nexport type {\n  ClientEditorConfig,\n  SanitizedClientEditorConfig,\n  SanitizedServerEditorConfig,\n  ServerEditorConfig,\n} from './field/lexical/config/types.js'\n\nexport { getEnabledNodes } from './field/lexical/nodes/index.js'\nexport { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type { AdapterProps }\n\nexport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nexport { CAN_USE_DOM } from './field/lexical/utils/canUseDOM.js'\nexport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nexport { getDOMRangeRect } from './field/lexical/utils/getDOMRangeRect.js'\nexport { getSelectedNode } from './field/lexical/utils/getSelectedNode.js'\nexport { isHTMLElement } from './field/lexical/utils/guard.js'\nexport { invariant } from './field/lexical/utils/invariant.js'\nexport { joinClasses } from './field/lexical/utils/joinClasses.js'\nexport { createBlockNode } from './field/lexical/utils/markdown/createBlockNode.js'\nexport {\n  DETAIL_TYPE_TO_DETAIL,\n  DOUBLE_LINE_BREAK,\n  ELEMENT_FORMAT_TO_TYPE,\n  ELEMENT_TYPE_TO_FORMAT,\n  IS_ALL_FORMATTING,\n  LTR_REGEX,\n  NON_BREAKING_SPACE,\n  NodeFormat,\n  RTL_REGEX,\n  TEXT_MODE_TO_TYPE,\n  TEXT_TYPE_TO_FORMAT,\n  TEXT_TYPE_TO_MODE,\n} from './field/lexical/utils/nodeFormat.js'\nexport { Point, isPoint } from './field/lexical/utils/point.js'\nexport { Rect } from './field/lexical/utils/rect.js'\nexport { setFloatingElemPosition } from './field/lexical/utils/setFloatingElemPosition.js'\nexport { setFloatingElemPositionForLinkEditor } from './field/lexical/utils/setFloatingElemPositionForLinkEditor.js'\nexport {\n  addSwipeDownListener,\n  addSwipeLeftListener,\n  addSwipeRightListener,\n  addSwipeUpListener,\n} from './field/lexical/utils/swipe.js'\nexport { sanitizeUrl, validateUrl } from './field/lexical/utils/url.js'\nexport { defaultRichTextValue } from './populate/defaultValue.js'\n\nexport type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n"],"names":["withMergedProps","withNullableJSONSchemaType","RichTextCell","RichTextField","defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerEditorConfig","sanitizeServerFeatures","cloneDeep","getGenerateComponentMap","getGenerateSchemaMap","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","draft","fieldPromises","findMany","flattenLocales","overrideAccess","req","showHiddenFields","siblingDoc","size","editorPopulationPromises","validate","AlignFeature","BlockQuoteFeature","BlocksFeature","$createBlockNode","$isBlockNode","BlockNode","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","createClientComponent","TestRecorderFeature","TreeViewFeature","BoldFeature","InlineCodeFeature","ItalicFeature","toolbarFormatGroupWithItems","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","$createAutoLinkNode","$isAutoLinkNode","AutoLinkNode","$createLinkNode","$isLinkNode","LinkNode","TOGGLE_LINK_COMMAND","ChecklistFeature","OrderedListFeature","UnorderedListFeature","LexicalPluginToLexicalFeature","SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters","convertSlateNodesToLexical","convertSlateToLexical","SlateToLexicalFeature","ParagraphFeature","RelationshipFeature","$createRelationshipNode","$isRelationshipNode","RelationshipNode","toolbarAddDropdownGroupWithItems","toolbarFeatureButtonsGroupWithItems","toolbarTextDropdownGroupWithItems","FixedToolbarFeature","InlineToolbarFeature","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","EditorConfigProvider","useEditorConfigContext","sanitizeClientEditorConfig","sanitizeClientFeatures","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","CAN_USE_DOM","getDOMRangeRect","getSelectedNode","isHTMLElement","invariant","joinClasses","createBlockNode","DETAIL_TYPE_TO_DETAIL","DOUBLE_LINE_BREAK","ELEMENT_FORMAT_TO_TYPE","ELEMENT_TYPE_TO_FORMAT","IS_ALL_FORMATTING","LTR_REGEX","NON_BREAKING_SPACE","NodeFormat","RTL_REGEX","TEXT_MODE_TO_TYPE","TEXT_TYPE_TO_FORMAT","TEXT_TYPE_TO_MODE","Point","isPoint","Rect","setFloatingElemPosition","setFloatingElemPositionForLinkEditor","addSwipeDownListener","addSwipeLeftListener","addSwipeRightListener","addSwipeUpListener","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/populate/populate.d.ts

@@ -6,13 +6,14 @@ type Arguments = {
     currentDepth?: number;
     data: unknown;
     depth: number;
+    draft: boolean;
     field: RichTextField<SerializedEditorState, AdapterProps>;
     key: number | string;
     overrideAccess?: boolean;
     req: PayloadRequestWithData;
     showHiddenFields: boolean;
 };
-export declare const populate: ({ id, collection, currentDepth, data, depth, key, overrideAccess, req, showHiddenFields, }: Omit<Arguments, 'field'> & {
+export declare const populate: ({ id, collection, currentDepth, data, depth, draft, key, overrideAccess, req, showHiddenFields, }: Omit<Arguments, 'field'> & {
     collection: Collection;
     field: Field;
     id: number | string;

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

package/dist/populate/populate.js

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

package/dist/populate/populate.js.map

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

package/dist/populate/populateLexicalPopulationPromises.d.ts

@@ -8,5 +8,5 @@ export type Args = Parameters<RichTextAdapter<SerializedEditorState, AdapterProp
 /**
  * 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;
+export declare const populateLexicalPopulationPromises: ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: Args) => void;
 //# sourceMappingURL=populateLexicalPopulationPromises.d.ts.map

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

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

package/dist/populate/populateLexicalPopulationPromises.js

@@ -1,7 +1,7 @@
 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 })=>{
+ */ export const populateLexicalPopulationPromises = ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
     if (depth <= 0 || currentDepth > depth) {
         return;
     }
@@ -13,6 +13,7 @@ import { recurseNodes } from '../forEachNodeRecursively.js';
                         context,
                         currentDepth,
                         depth,
+                        draft,
                         editorPopulationPromises,
                         field,
                         fieldPromises,

package/dist/populate/populateLexicalPopulationPromises.js.map

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

package/dist/populate/recurseNestedFields.d.ts

@@ -6,6 +6,7 @@ type NestedRichTextFieldsArgs = {
     currentDepth?: number;
     data: unknown;
     depth: number;
+    draft: boolean;
     /**
      * This maps all the population promises to the node types
      */
@@ -23,6 +24,6 @@ type NestedRichTextFieldsArgs = {
     showHiddenFields: boolean;
     siblingDoc: Record<string, unknown>;
 };
-export declare const recurseNestedFields: ({ context, currentDepth, data, depth, fieldPromises, fields, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: NestedRichTextFieldsArgs) => void;
+export declare const recurseNestedFields: ({ context, currentDepth, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: NestedRichTextFieldsArgs) => void;
 export {};
 //# sourceMappingURL=recurseNestedFields.d.ts.map

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

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

package/dist/populate/recurseNestedFields.js

@@ -1,11 +1,12 @@
 import { afterReadTraverseFields } from 'payload/utilities';
-export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, fieldPromises, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, req, showHiddenFields, siblingDoc })=>{
+export const recurseNestedFields = ({ context, currentDepth = 0, data, depth, draft, fieldPromises, fields, findMany, flattenLocales, overrideAccess = false, populationPromises, req, showHiddenFields, siblingDoc })=>{
     afterReadTraverseFields({
         collection: null,
         context,
         currentDepth,
         depth,
         doc: data,
+        draft,
         fallbackLocale: req.fallbackLocale,
         fieldPromises,
         fields,

package/dist/populate/recurseNestedFields.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/richtext-lexical",
-  "version": "3.0.0-alpha.68",
+  "version": "3.0.0-alpha.69",
   "description": "The officially supported Lexical richtext adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "packages/richtext-lexical"
   },
   "license": "MIT",
-  "author": "Payload CMS, Inc.",
+  "author": "Payload <dev@payloadcms.com> (https://payloadcms.com)",
   "type": "module",
   "exports": {
     ".": {
@@ -57,18 +57,18 @@
     "@types/react": "18.2.74",
     "@types/react-dom": "18.2.24",
     "@payloadcms/eslint-config": "1.1.1",
-    "@payloadcms/next": "3.0.0-alpha.68",
-    "payload": "3.0.0-alpha.68",
-    "@payloadcms/ui": "3.0.0-alpha.68",
-    "@payloadcms/translations": "3.0.0-alpha.68"
+    "@payloadcms/next": "3.0.0-alpha.69",
+    "@payloadcms/ui": "3.0.0-alpha.69",
+    "@payloadcms/translations": "3.0.0-alpha.69",
+    "payload": "3.0.0-alpha.69"
   },
   "peerDependencies": {
     "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.68",
-    "@payloadcms/translations": "3.0.0-alpha.68",
-    "@payloadcms/ui": "3.0.0-alpha.68",
-    "payload": "3.0.0-alpha.68"
+    "@payloadcms/next": "3.0.0-alpha.69",
+    "payload": "3.0.0-alpha.69",
+    "@payloadcms/ui": "3.0.0-alpha.69",
+    "@payloadcms/translations": "3.0.0-alpha.69"
   },
   "engines": {
     "node": ">=18.20.2"

package/dist/field/features/align/inlineToolbarAlignGroup.d.ts

@@ -1,3 +0,0 @@
-import type { InlineToolbarGroup, InlineToolbarGroupItem } from '../../lexical/plugins/toolbars/inline/types.js';
-export declare const alignGroupWithItems: (items: InlineToolbarGroupItem[]) => InlineToolbarGroup;
-//# sourceMappingURL=inlineToolbarAlignGroup.d.ts.map

package/dist/field/features/align/inlineToolbarAlignGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inlineToolbarAlignGroup.d.ts","sourceRoot":"","sources":["../../../../src/field/features/align/inlineToolbarAlignGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,gDAAgD,CAAA;AAIvD,eAAO,MAAM,mBAAmB,UAAW,sBAAsB,EAAE,KAAG,kBAQrE,CAAA"}

package/dist/field/features/align/inlineToolbarAlignGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/align/inlineToolbarAlignGroup.ts"],"sourcesContent":["import type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from '../../lexical/plugins/toolbars/inline/types.js'\n\nimport { AlignLeftIcon } from '../../lexical/ui/icons/AlignLeft/index.js'\n\nexport const alignGroupWithItems = (items: InlineToolbarGroupItem[]): InlineToolbarGroup => {\n  return {\n    type: 'dropdown',\n    ChildComponent: AlignLeftIcon,\n    items,\n    key: 'align',\n    order: 2,\n  }\n}\n"],"names":["AlignLeftIcon","alignGroupWithItems","items","type","ChildComponent","key","order"],"rangeMappings":";;;;;;;;;","mappings":"AAKA,SAASA,aAAa,QAAQ,4CAA2C;AAEzE,OAAO,MAAMC,sBAAsB,CAACC;IAClC,OAAO;QACLC,MAAM;QACNC,gBAAgBJ;QAChBE;QACAG,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/format/shared/inlineToolbarFormatGroup.d.ts

@@ -1,3 +0,0 @@
-import type { InlineToolbarGroup, InlineToolbarGroupItem } from '../../../lexical/plugins/toolbars/inline/types.js';
-export declare const inlineToolbarFormatGroupWithItems: (items: InlineToolbarGroupItem[]) => InlineToolbarGroup;
-//# sourceMappingURL=inlineToolbarFormatGroup.d.ts.map

package/dist/field/features/format/shared/inlineToolbarFormatGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inlineToolbarFormatGroup.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/format/shared/inlineToolbarFormatGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,mDAAmD,CAAA;AAE1D,eAAO,MAAM,iCAAiC,UACrC,sBAAsB,EAAE,KAC9B,kBAOF,CAAA"}

package/dist/field/features/format/shared/inlineToolbarFormatGroup.js

@@ -1,10 +0,0 @@
-export const inlineToolbarFormatGroupWithItems = (items)=>{
-    return {
-        type: 'buttons',
-        items,
-        key: 'format',
-        order: 4
-    };
-};
-
-//# sourceMappingURL=inlineToolbarFormatGroup.js.map

package/dist/field/features/format/shared/inlineToolbarFormatGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/format/shared/inlineToolbarFormatGroup.ts"],"sourcesContent":["import type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from '../../../lexical/plugins/toolbars/inline/types.js'\n\nexport const inlineToolbarFormatGroupWithItems = (\n  items: InlineToolbarGroupItem[],\n): InlineToolbarGroup => {\n  return {\n    type: 'buttons',\n    items,\n    key: 'format',\n    order: 4,\n  }\n}\n"],"names":["inlineToolbarFormatGroupWithItems","items","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,oCAAoC,CAC/CC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/indent/inlineToolbarIndentGroup.d.ts

@@ -1,3 +0,0 @@
-import type { InlineToolbarGroup, InlineToolbarGroupItem } from '../../lexical/plugins/toolbars/inline/types.js';
-export declare const indentGroupWithItems: (items: InlineToolbarGroupItem[]) => InlineToolbarGroup;
-//# sourceMappingURL=inlineToolbarIndentGroup.d.ts.map

package/dist/field/features/indent/inlineToolbarIndentGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inlineToolbarIndentGroup.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/inlineToolbarIndentGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,gDAAgD,CAAA;AAEvD,eAAO,MAAM,oBAAoB,UAAW,sBAAsB,EAAE,KAAG,kBAOtE,CAAA"}

package/dist/field/features/indent/inlineToolbarIndentGroup.js

@@ -1,10 +0,0 @@
-export const indentGroupWithItems = (items)=>{
-    return {
-        type: 'buttons',
-        items,
-        key: 'indent',
-        order: 3
-    };
-};
-
-//# sourceMappingURL=inlineToolbarIndentGroup.js.map

package/dist/field/features/indent/inlineToolbarIndentGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/indent/inlineToolbarIndentGroup.ts"],"sourcesContent":["import type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from '../../lexical/plugins/toolbars/inline/types.js'\n\nexport const indentGroupWithItems = (items: InlineToolbarGroupItem[]): InlineToolbarGroup => {\n  return {\n    type: 'buttons',\n    items,\n    key: 'indent',\n    order: 3,\n  }\n}\n"],"names":["indentGroupWithItems","items","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,uBAAuB,CAACC;IACnC,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/shared/inlineToolbar/featureButtonsGroup.d.ts

@@ -1,3 +0,0 @@
-import type { InlineToolbarGroup, InlineToolbarGroupItem } from '../../../lexical/plugins/toolbars/inline/types.js';
-export declare const inlineToolbarFeatureButtonsGroupWithItems: (items: InlineToolbarGroupItem[]) => InlineToolbarGroup;
-//# sourceMappingURL=featureButtonsGroup.d.ts.map

package/dist/field/features/shared/inlineToolbar/featureButtonsGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"featureButtonsGroup.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/shared/inlineToolbar/featureButtonsGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,mDAAmD,CAAA;AAE1D,eAAO,MAAM,yCAAyC,UAC7C,sBAAsB,EAAE,KAC9B,kBAOF,CAAA"}

package/dist/field/features/shared/inlineToolbar/featureButtonsGroup.js

@@ -1,10 +0,0 @@
-export const inlineToolbarFeatureButtonsGroupWithItems = (items)=>{
-    return {
-        type: 'buttons',
-        items,
-        key: 'features',
-        order: 5
-    };
-};
-
-//# sourceMappingURL=featureButtonsGroup.js.map

package/dist/field/features/shared/inlineToolbar/featureButtonsGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/shared/inlineToolbar/featureButtonsGroup.ts"],"sourcesContent":["import type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from '../../../lexical/plugins/toolbars/inline/types.js'\n\nexport const inlineToolbarFeatureButtonsGroupWithItems = (\n  items: InlineToolbarGroupItem[],\n): InlineToolbarGroup => {\n  return {\n    type: 'buttons',\n    items,\n    key: 'features',\n    order: 5,\n  }\n}\n"],"names":["inlineToolbarFeatureButtonsGroupWithItems","items","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,4CAA4C,CACvDC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/shared/inlineToolbar/textDropdownGroup.d.ts

@@ -1,3 +0,0 @@
-import type { InlineToolbarGroup, InlineToolbarGroupItem } from '../../../lexical/plugins/toolbars/inline/types.js';
-export declare const inlineToolbarTextDropdownGroupWithItems: (items: InlineToolbarGroupItem[]) => InlineToolbarGroup;
-//# sourceMappingURL=textDropdownGroup.d.ts.map

package/dist/field/features/shared/inlineToolbar/textDropdownGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"textDropdownGroup.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/shared/inlineToolbar/textDropdownGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,mDAAmD,CAAA;AAI1D,eAAO,MAAM,uCAAuC,UAC3C,sBAAsB,EAAE,KAC9B,kBAQF,CAAA"}

package/dist/field/features/shared/inlineToolbar/textDropdownGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/shared/inlineToolbar/textDropdownGroup.ts"],"sourcesContent":["import type {\n  InlineToolbarGroup,\n  InlineToolbarGroupItem,\n} from '../../../lexical/plugins/toolbars/inline/types.js'\n\nimport { TextIcon } from '../../../lexical/ui/icons/Text/index.js'\n\nexport const inlineToolbarTextDropdownGroupWithItems = (\n  items: InlineToolbarGroupItem[],\n): InlineToolbarGroup => {\n  return {\n    type: 'dropdown',\n    ChildComponent: TextIcon,\n    items,\n    key: 'text',\n    order: 1,\n  }\n}\n"],"names":["TextIcon","inlineToolbarTextDropdownGroupWithItems","items","type","ChildComponent","key","order"],"rangeMappings":";;;;;;;;;","mappings":"AAKA,SAASA,QAAQ,QAAQ,0CAAyC;AAElE,OAAO,MAAMC,0CAA0C,CACrDC;IAEA,OAAO;QACLC,MAAM;QACNC,gBAAgBJ;QAChBE;QACAG,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/lexical/plugins/toolbars/fixed/types.d.ts

@@ -1,40 +0,0 @@
-import type { BaseSelection, LexicalEditor } from 'lexical';
-import type React from 'react';
-export type FixedToolbarGroup = {
-    ChildComponent?: React.FC;
-    items: Array<FixedToolbarGroupItem>;
-    key: string;
-    order?: number;
-    type: 'dropdown';
-} | {
-    items: Array<FixedToolbarGroupItem>;
-    key: string;
-    order?: number;
-    type: 'buttons';
-};
-export type FixedToolbarGroupItem = {
-    ChildComponent?: React.FC;
-    /** Use component to ignore the children and onClick properties. It does not use the default, pre-defined format Button component */
-    Component?: React.FC<{
-        anchorElem: HTMLElement;
-        editor: LexicalEditor;
-        item: FixedToolbarGroupItem;
-    }>;
-    isActive?: ({ editor, selection }: {
-        editor: LexicalEditor;
-        selection: BaseSelection;
-    }) => boolean;
-    isEnabled?: ({ editor, selection, }: {
-        editor: LexicalEditor;
-        selection: BaseSelection;
-    }) => boolean;
-    key: string;
-    /** The label is displayed as text if the item is part of a dropdown group */
-    label?: string;
-    onClick?: ({ editor, isActive }: {
-        editor: LexicalEditor;
-        isActive: boolean;
-    }) => void;
-    order?: number;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/field/lexical/plugins/toolbars/fixed/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/toolbars/fixed/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC3D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,iBAAiB,GACzB;IACE,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,KAAK,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAA;IACnC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;CACjB,GACD;IACE,KAAK,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAA;IACnC,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,oIAAoI;IACpI,SAAS,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;QACnB,UAAU,EAAE,WAAW,CAAA;QACvB,MAAM,EAAE,aAAa,CAAA;QACrB,IAAI,EAAE,qBAAqB,CAAA;KAC5B,CAAC,CAAA;IACF,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,SAAS,EAAE,aAAa,CAAA;KAAE,KAAK,OAAO,CAAA;IAClG,SAAS,CAAC,EAAE,CAAC,EACX,MAAM,EACN,SAAS,GACV,EAAE;QACD,MAAM,EAAE,aAAa,CAAA;QACrB,SAAS,EAAE,aAAa,CAAA;KACzB,KAAK,OAAO,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACtF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA"}