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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/richtext-lexical",
-  "version": "3.0.0-alpha.67",
+  "version": "3.0.0-alpha.68",
   "description": "The officially supported Lexical richtext adapter for Payload",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -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.67",
-    "@payloadcms/translations": "3.0.0-alpha.67",
-    "@payloadcms/ui": "3.0.0-alpha.67",
-    "payload": "3.0.0-alpha.67"
+    "@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"
   },
   "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.67",
-    "@payloadcms/translations": "3.0.0-alpha.67",
-    "@payloadcms/ui": "3.0.0-alpha.67",
-    "payload": "3.0.0-alpha.67"
+    "@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"
   },
   "engines": {
     "node": ">=18.20.2"

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

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const AlignDropdownSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=floatingSelectToolbarAlignDropdownSection.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"floatingSelectToolbarAlignDropdownSection.d.ts","sourceRoot":"","sources":["../../../../src/field/features/align/floatingSelectToolbarAlignDropdownSection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,sDAAsD,CAAA;AAI7D,eAAO,MAAM,+BAA+B,YACjC,2BAA2B,EAAE,KACrC,sBAQF,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/align/floatingSelectToolbarAlignDropdownSection.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nimport { AlignLeftIcon } from '../../lexical/ui/icons/AlignLeft/index.js'\n\nexport const AlignDropdownSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'dropdown',\n    ChildComponent: AlignLeftIcon,\n    entries,\n    key: 'dropdown-align',\n    order: 2,\n  }\n}\n"],"names":["AlignLeftIcon","AlignDropdownSectionWithEntries","entries","type","ChildComponent","key","order"],"rangeMappings":";;;;;;;;;","mappings":"AAKA,SAASA,aAAa,QAAQ,4CAA2C;AAEzE,OAAO,MAAMC,kCAAkC,CAC7CC;IAEA,OAAO;QACLC,MAAM;QACNC,gBAAgBJ;QAChBE;QACAG,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const FeaturesSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,yDAAyD,CAAA;AAEhE,eAAO,MAAM,0BAA0B,YAC5B,2BAA2B,EAAE,KACrC,sBAOF,CAAA"}

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.js

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

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nexport const FeaturesSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'buttons',\n    entries,\n    key: 'features',\n    order: 5,\n  }\n}\n"],"names":["FeaturesSectionWithEntries","entries","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,6BAA6B,CACxCC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const TextDropdownSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,yDAAyD,CAAA;AAIhE,eAAO,MAAM,8BAA8B,YAChC,2BAA2B,EAAE,KACrC,sBAQF,CAAA"}

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nimport { TextIcon } from '../../../lexical/ui/icons/Text/index.js'\n\nexport const TextDropdownSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'dropdown',\n    ChildComponent: TextIcon,\n    entries,\n    key: 'dropdown-text',\n    order: 1,\n  }\n}\n"],"names":["TextIcon","TextDropdownSectionWithEntries","entries","type","ChildComponent","key","order"],"rangeMappings":";;;;;;;;;","mappings":"AAKA,SAASA,QAAQ,QAAQ,0CAAyC;AAElE,OAAO,MAAMC,iCAAiC,CAC5CC;IAEA,OAAO;QACLC,MAAM;QACNC,gBAAgBJ;QAChBE;QACAG,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/format/common/floatingSelectToolbarSection.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const SectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=floatingSelectToolbarSection.d.ts.map

package/dist/field/features/format/common/floatingSelectToolbarSection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floatingSelectToolbarSection.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/format/common/floatingSelectToolbarSection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,yDAAyD,CAAA;AAEhE,eAAO,MAAM,kBAAkB,YACpB,2BAA2B,EAAE,KACrC,sBAOF,CAAA"}

package/dist/field/features/format/common/floatingSelectToolbarSection.js

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

package/dist/field/features/format/common/floatingSelectToolbarSection.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/format/common/floatingSelectToolbarSection.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nexport const SectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'buttons',\n    entries,\n    key: 'format',\n    order: 4,\n  }\n}\n"],"names":["SectionWithEntries","entries","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,qBAAqB,CAChCC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/format/inlinecode/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/format/inlinecode/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { $isRangeSelection, FORMAT_TEXT_COMMAND } from 'lexical'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { CodeIcon } from '../../../lexical/ui/icons/Code/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { SectionWithEntries } from '../common/floatingSelectToolbarSection.js'\nimport { INLINE_CODE } from './markdownTransformers.js'\n\nconst InlineCodeFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => {\n      return {\n        clientFeatureProps: props,\n        floatingSelectToolbar: {\n          sections: [\n            SectionWithEntries([\n              {\n                ChildComponent: CodeIcon,\n                isActive: ({ selection }) => {\n                  if ($isRangeSelection(selection)) {\n                    return selection.hasFormat('code')\n                  }\n                  return false\n                },\n                key: 'code',\n                onClick: ({ editor }) => {\n                  editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code')\n                },\n                order: 7,\n              },\n            ]),\n          ],\n        },\n\n        markdownTransformers: [INLINE_CODE],\n      }\n    },\n  }\n}\n\nexport const InlineCodeFeatureClientComponent = createClientComponent(InlineCodeFeatureClient)\n"],"names":["$isRangeSelection","FORMAT_TEXT_COMMAND","CodeIcon","createClientComponent","SectionWithEntries","INLINE_CODE","InlineCodeFeatureClient","props","clientFeatureProps","feature","floatingSelectToolbar","sections","ChildComponent","isActive","selection","hasFormat","key","onClick","editor","dispatchCommand","order","markdownTransformers","InlineCodeFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,iBAAiB,EAAEC,mBAAmB,QAAQ,UAAS;AAIhE,SAASC,QAAQ,QAAQ,0CAAyC;AAClE,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,kBAAkB,QAAQ,4CAA2C;AAC9E,SAASC,WAAW,QAAQ,4BAA2B;AAEvD,MAAMC,0BAAoE,CAACC;IACzE,OAAO;QACLC,oBAAoBD;QACpBE,SAAS;YACP,OAAO;gBACLD,oBAAoBD;gBACpBG,uBAAuB;oBACrBC,UAAU;wBACRP,mBAAmB;4BACjB;gCACEQ,gBAAgBV;gCAChBW,UAAU,CAAC,EAAEC,SAAS,EAAE;oCACtB,IAAId,kBAAkBc,YAAY;wCAChC,OAAOA,UAAUC,SAAS,CAAC;oCAC7B;oCACA,OAAO;gCACT;gCACAC,KAAK;gCACLC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAAClB,qBAAqB;gCAC9C;gCACAmB,OAAO;4BACT;yBACD;qBACF;gBACH;gBAEAC,sBAAsB;oBAAChB;iBAAY;YACrC;QACF;IACF;AACF;AAEA,OAAO,MAAMiB,mCAAmCnB,sBAAsBG,yBAAwB"}

package/dist/field/features/horizontalrule/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/horizontalrule/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js'\nimport { HorizontalRulePlugin } from './plugin/index.js'\n\nconst HorizontalRuleFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      markdownTransformers: [MarkdownTransformer],\n      nodes: [HorizontalRuleNode],\n      plugins: [\n        {\n          Component: HorizontalRulePlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        options: [\n          {\n            displayName: 'Basic',\n            key: 'basic',\n            options: [\n              new SlashMenuOption(`horizontalrule`, {\n                Icon: HorizontalRuleIcon,\n                displayName: `Horizontal Rule`,\n                keywords: ['hr', 'horizontal rule', 'line', 'separator'],\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n                },\n              }),\n            ],\n          },\n        ],\n      },\n    }),\n  }\n}\n\nexport const HorizontalRuleFeatureClientComponent = createClientComponent(\n  HorizontalRuleFeatureClient,\n)\n"],"names":["SlashMenuOption","HorizontalRuleIcon","createClientComponent","MarkdownTransformer","HorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","HorizontalRuleFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","options","displayName","key","Icon","keywords","onSelect","editor","dispatchCommand","undefined","HorizontalRuleFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,eAAe,QAAQ,sEAAqE;AACrG,SAASC,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,EAAEC,8BAA8B,QAAQ,gCAA+B;AAClG,SAASC,oBAAoB,QAAQ,oBAAmB;AAExD,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,sBAAsB;oBAACR;iBAAoB;gBAC3CS,OAAO;oBAACR;iBAAmB;gBAC3BS,SAAS;oBACP;wBACEC,WAAWR;wBACXS,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbC,KAAK;4BACLF,SAAS;gCACP,IAAIjB,gBAAgB,CAAC,cAAc,CAAC,EAAE;oCACpCoB,MAAMnB;oCACNiB,aAAa,CAAC,eAAe,CAAC;oCAC9BG,UAAU;wCAAC;wCAAM;wCAAmB;wCAAQ;qCAAY;oCACxDC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACnB,gCAAgCoB;oCACzD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,uCAAuCxB,sBAClDK,6BACD"}

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

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const IndentSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=floatingSelectToolbarIndentSection.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"floatingSelectToolbarIndentSection.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/floatingSelectToolbarIndentSection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,sDAAsD,CAAA;AAE7D,eAAO,MAAM,wBAAwB,YAC1B,2BAA2B,EAAE,KACrC,sBAOF,CAAA"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/indent/floatingSelectToolbarIndentSection.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nexport const IndentSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'buttons',\n    entries,\n    key: 'indent',\n    order: 3,\n  }\n}\n"],"names":["IndentSectionWithEntries","entries","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,2BAA2B,CACtCC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/indent/index.scss

@@ -1,4 +0,0 @@
-.floating-select-toolbar-popup__section-indent {
-  display: flex;
-  gap: 2px;
-}

package/dist/field/features/lists/orderedlist/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/orderedlist/feature.client.tsx"],"sourcesContent":["'use client'\nimport { INSERT_ORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { SlashMenuOption } from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { OrderedListIcon } from '../../../lexical/ui/icons/OrderedList/index.js'\nimport { TextDropdownSectionWithEntries } from '../../common/floatingSelectToolbarTextDropdownSection/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { ORDERED_LIST } from './markdownTransformer.js'\n\nconst OrderedListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ featureProviderMap }) => {\n      return {\n        clientFeatureProps: props,\n        floatingSelectToolbar: {\n          sections: [\n            TextDropdownSectionWithEntries([\n              {\n                ChildComponent: OrderedListIcon,\n                isActive: () => false,\n                key: 'orderedList',\n                label: `Ordered List`,\n                onClick: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined)\n                },\n                order: 10,\n              },\n            ]),\n          ],\n        },\n        markdownTransformers: [ORDERED_LIST],\n        nodes: featureProviderMap.has('unorderedlist') ? [] : [ListNode, ListItemNode],\n        plugins: featureProviderMap.has('unorderedlist')\n          ? []\n          : [\n              {\n                Component: LexicalListPlugin,\n                position: 'normal',\n              },\n            ],\n        slashMenu: {\n          options: [\n            {\n              displayName: 'Lists',\n              key: 'lists',\n              options: [\n                new SlashMenuOption('orderedlist', {\n                  Icon: OrderedListIcon,\n                  displayName: 'Ordered List',\n                  keywords: ['ordered list', 'ol'],\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined)\n                  },\n                }),\n              ],\n            },\n          ],\n        },\n      }\n    },\n  }\n}\n\nexport const OrderedListFeatureClientComponent = createClientComponent(OrderedListFeatureClient)\n"],"names":["INSERT_ORDERED_LIST_COMMAND","ListItemNode","ListNode","SlashMenuOption","OrderedListIcon","TextDropdownSectionWithEntries","createClientComponent","LexicalListPlugin","ORDERED_LIST","OrderedListFeatureClient","props","clientFeatureProps","feature","featureProviderMap","floatingSelectToolbar","sections","ChildComponent","isActive","key","label","onClick","editor","dispatchCommand","undefined","order","markdownTransformers","nodes","has","plugins","Component","position","slashMenu","options","displayName","Icon","keywords","onSelect","OrderedListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,2BAA2B,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAInF,SAASC,eAAe,QAAQ,yEAAwE;AACxG,SAASC,eAAe,QAAQ,iDAAgD;AAChF,SAASC,8BAA8B,QAAQ,iEAAgE;AAC/G,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,YAAY,QAAQ,2BAA0B;AAEvD,MAAMC,2BAAqE,CAACC;IAC1E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,kBAAkB,EAAE;YAC9B,OAAO;gBACLF,oBAAoBD;gBACpBI,uBAAuB;oBACrBC,UAAU;wBACRV,+BAA+B;4BAC7B;gCACEW,gBAAgBZ;gCAChBa,UAAU,IAAM;gCAChBC,KAAK;gCACLC,OAAO,CAAC,YAAY,CAAC;gCACrBC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAACtB,6BAA6BuB;gCACtD;gCACAC,OAAO;4BACT;yBACD;qBACF;gBACH;gBACAC,sBAAsB;oBAACjB;iBAAa;gBACpCkB,OAAOb,mBAAmBc,GAAG,CAAC,mBAAmB,EAAE,GAAG;oBAACzB;oBAAUD;iBAAa;gBAC9E2B,SAASf,mBAAmBc,GAAG,CAAC,mBAC5B,EAAE,GACF;oBACE;wBACEE,WAAWtB;wBACXuB,UAAU;oBACZ;iBACD;gBACLC,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbf,KAAK;4BACLc,SAAS;gCACP,IAAI7B,gBAAgB,eAAe;oCACjC+B,MAAM9B;oCACN6B,aAAa;oCACbE,UAAU;wCAAC;wCAAgB;qCAAK;oCAChCC,UAAU,CAAC,EAAEf,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACtB,6BAA6BuB;oCACtD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMc,oCAAoC/B,sBAAsBG,0BAAyB"}

package/dist/field/features/lists/unorderedlist/feature.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedlist/feature.client.tsx"],"names":[],"mappings":";AAkEA,eAAO,MAAM,mCAAmC,+BAAoD,CAAA"}

package/dist/field/features/lists/unorderedlist/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/lists/unorderedlist/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { SlashMenuOption } from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { UnorderedListIcon } from '../../../lexical/ui/icons/UnorderedList/index.js'\nimport { TextDropdownSectionWithEntries } from '../../common/floatingSelectToolbarTextDropdownSection/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { UNORDERED_LIST } from './markdownTransformer.js'\n\nconst UnorderedListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => {\n      return {\n        clientFeatureProps: props,\n        floatingSelectToolbar: {\n          sections: [\n            TextDropdownSectionWithEntries([\n              {\n                ChildComponent: UnorderedListIcon,\n                isActive: () => false,\n                key: 'unorderedList',\n                label: `Unordered List`,\n                onClick: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n                },\n                order: 11,\n              },\n            ]),\n          ],\n        },\n        markdownTransformers: [UNORDERED_LIST],\n        nodes: [ListNode, ListItemNode],\n        plugins: [\n          {\n            Component: LexicalListPlugin,\n            position: 'normal',\n          },\n        ],\n        slashMenu: {\n          options: [\n            {\n              displayName: 'Lists',\n              key: 'lists',\n              options: [\n                new SlashMenuOption('unorderedlist', {\n                  Icon: UnorderedListIcon,\n                  displayName: 'Unordered List',\n                  keywords: ['unordered list', 'ul'],\n                  onSelect: ({ editor }) => {\n                    editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n                  },\n                }),\n              ],\n            },\n          ],\n        },\n      }\n    },\n  }\n}\n\nexport const UnorderedListFeatureClientComponent = createClientComponent(UnorderedListFeatureClient)\n"],"names":["INSERT_UNORDERED_LIST_COMMAND","ListItemNode","ListNode","SlashMenuOption","UnorderedListIcon","TextDropdownSectionWithEntries","createClientComponent","LexicalListPlugin","UNORDERED_LIST","UnorderedListFeatureClient","props","clientFeatureProps","feature","floatingSelectToolbar","sections","ChildComponent","isActive","key","label","onClick","editor","dispatchCommand","undefined","order","markdownTransformers","nodes","plugins","Component","position","slashMenu","options","displayName","Icon","keywords","onSelect","UnorderedListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,6BAA6B,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAIrF,SAASC,eAAe,QAAQ,yEAAwE;AACxG,SAASC,iBAAiB,QAAQ,mDAAkD;AACpF,SAASC,8BAA8B,QAAQ,iEAAgE;AAC/G,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,cAAc,QAAQ,2BAA0B;AAEzD,MAAMC,6BAAuE,CAACC;IAC5E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS;YACP,OAAO;gBACLD,oBAAoBD;gBACpBG,uBAAuB;oBACrBC,UAAU;wBACRT,+BAA+B;4BAC7B;gCACEU,gBAAgBX;gCAChBY,UAAU,IAAM;gCAChBC,KAAK;gCACLC,OAAO,CAAC,cAAc,CAAC;gCACvBC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAACrB,+BAA+BsB;gCACxD;gCACAC,OAAO;4BACT;yBACD;qBACF;gBACH;gBACAC,sBAAsB;oBAAChB;iBAAe;gBACtCiB,OAAO;oBAACvB;oBAAUD;iBAAa;gBAC/ByB,SAAS;oBACP;wBACEC,WAAWpB;wBACXqB,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbd,KAAK;4BACLa,SAAS;gCACP,IAAI3B,gBAAgB,iBAAiB;oCACnC6B,MAAM5B;oCACN2B,aAAa;oCACbE,UAAU;wCAAC;wCAAkB;qCAAK;oCAClCC,UAAU,CAAC,EAAEd,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACrB,+BAA+BsB;oCACxD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMa,sCAAsC7B,sBAAsBG,4BAA2B"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { FloatingToolbarSectionEntry } from '../types.js';
-import './index.scss';
-export declare const ToolbarButton: ({ children, entry, }: {
-    children: React.JSX.Element;
-    entry: FloatingToolbarSectionEntry;
-}) => React.JSX.Element;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAE9D,OAAO,cAAc,CAAA;AAIrB,eAAO,MAAM,aAAa,yBAGvB;IACD,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;IAC3B,KAAK,EAAE,2BAA2B,CAAA;CACnC,sBA8EA,CAAA"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { mergeRegister } from '@lexical/utils'\nimport { $getSelection } from 'lexical'\nimport React, { useCallback, useEffect, useState } from 'react'\n\nimport type { FloatingToolbarSectionEntry } from '../types.js'\n\nimport './index.scss'\n\nconst baseClass = 'floating-select-toolbar-popup__button'\n\nexport const ToolbarButton = ({\n  children,\n  entry,\n}: {\n  children: React.JSX.Element\n  entry: FloatingToolbarSectionEntry\n}) => {\n  const [editor] = useLexicalComposerContext()\n  const [enabled, setEnabled] = useState<boolean>(true)\n  const [active, setActive] = useState<boolean>(false)\n  const [className, setClassName] = useState<string>(baseClass)\n\n  const updateStates = useCallback(() => {\n    editor.getEditorState().read(() => {\n      const selection = $getSelection()\n      if (entry.isActive) {\n        const isActive = entry.isActive({ editor, selection })\n        if (active !== isActive) {\n          setActive(isActive)\n        }\n      }\n      if (entry.isEnabled) {\n        const isEnabled = entry.isEnabled({ editor, selection })\n        if (enabled !== isEnabled) {\n          setEnabled(isEnabled)\n        }\n      }\n    })\n  }, [active, editor, enabled, entry])\n\n  useEffect(() => {\n    updateStates()\n  }, [updateStates])\n\n  useEffect(() => {\n    document.addEventListener('mouseup', updateStates)\n    return () => {\n      document.removeEventListener('mouseup', updateStates)\n    }\n  }, [updateStates])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updateStates()\n      }),\n    )\n  }, [editor, updateStates])\n\n  useEffect(() => {\n    setClassName(\n      [\n        baseClass,\n        enabled === false ? 'disabled' : '',\n        active ? 'active' : '',\n        entry?.key ? `${baseClass}-` + entry.key : '',\n      ]\n        .filter(Boolean)\n        .join(' '),\n    )\n  }, [enabled, active, className])\n\n  return (\n    <button\n      className={className}\n      onClick={() => {\n        if (enabled !== false) {\n          entry.onClick({\n            editor,\n            isActive: active,\n          })\n        }\n      }}\n      onMouseDown={(e) => {\n        // This fixes a bug where you are unable to click the button if you are in a NESTED editor (editor in blocks field in editor).\n        // Thus only happens if you click on the SVG of the button. Clicking on the outside works. Related issue: https://github.com/payloadcms/payload/issues/4025\n        // TODO: Find out why exactly it happens and why e.preventDefault() on the mouseDown fixes it. Write that down here, or potentially fix a root cause, if there is any.\n        e.preventDefault()\n      }}\n      type=\"button\"\n    >\n      {children}\n    </button>\n  )\n}\n"],"names":["useLexicalComposerContext","mergeRegister","$getSelection","React","useCallback","useEffect","useState","baseClass","ToolbarButton","children","entry","editor","enabled","setEnabled","active","setActive","className","setClassName","updateStates","getEditorState","read","selection","isActive","isEnabled","document","addEventListener","removeEventListener","registerUpdateListener","key","filter","Boolean","join","button","onClick","onMouseDown","e","preventDefault","type"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,aAAa,QAAQ,iBAAgB;AAC9C,SAASC,aAAa,QAAQ,UAAS;AACvC,OAAOC,SAASC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAI/D,OAAO,eAAc;AAErB,MAAMC,YAAY;AAElB,OAAO,MAAMC,gBAAgB,CAAC,EAC5BC,QAAQ,EACRC,KAAK,EAIN;IACC,MAAM,CAACC,OAAO,GAAGX;IACjB,MAAM,CAACY,SAASC,WAAW,GAAGP,SAAkB;IAChD,MAAM,CAACQ,QAAQC,UAAU,GAAGT,SAAkB;IAC9C,MAAM,CAACU,WAAWC,aAAa,GAAGX,SAAiBC;IAEnD,MAAMW,eAAed,YAAY;QAC/BO,OAAOQ,cAAc,GAAGC,IAAI,CAAC;YAC3B,MAAMC,YAAYnB;YAClB,IAAIQ,MAAMY,QAAQ,EAAE;gBAClB,MAAMA,WAAWZ,MAAMY,QAAQ,CAAC;oBAAEX;oBAAQU;gBAAU;gBACpD,IAAIP,WAAWQ,UAAU;oBACvBP,UAAUO;gBACZ;YACF;YACA,IAAIZ,MAAMa,SAAS,EAAE;gBACnB,MAAMA,YAAYb,MAAMa,SAAS,CAAC;oBAAEZ;oBAAQU;gBAAU;gBACtD,IAAIT,YAAYW,WAAW;oBACzBV,WAAWU;gBACb;YACF;QACF;IACF,GAAG;QAACT;QAAQH;QAAQC;QAASF;KAAM;IAEnCL,UAAU;QACRa;IACF,GAAG;QAACA;KAAa;IAEjBb,UAAU;QACRmB,SAASC,gBAAgB,CAAC,WAAWP;QACrC,OAAO;YACLM,SAASE,mBAAmB,CAAC,WAAWR;QAC1C;IACF,GAAG;QAACA;KAAa;IAEjBb,UAAU;QACR,OAAOJ,cACLU,OAAOgB,sBAAsB,CAAC;YAC5BT;QACF;IAEJ,GAAG;QAACP;QAAQO;KAAa;IAEzBb,UAAU;QACRY,aACE;YACEV;YACAK,YAAY,QAAQ,aAAa;YACjCE,SAAS,WAAW;YACpBJ,OAAOkB,MAAM,CAAC,EAAErB,UAAU,CAAC,CAAC,GAAGG,MAAMkB,GAAG,GAAG;SAC5C,CACEC,MAAM,CAACC,SACPC,IAAI,CAAC;IAEZ,GAAG;QAACnB;QAASE;QAAQE;KAAU;IAE/B,qBACE,oBAACgB;QACChB,WAAWA;QACXiB,SAAS;YACP,IAAIrB,YAAY,OAAO;gBACrBF,MAAMuB,OAAO,CAAC;oBACZtB;oBACAW,UAAUR;gBACZ;YACF;QACF;QACAoB,aAAa,CAACC;YACZ,8HAA8H;YAC9H,2JAA2J;YAC3J,sKAAsK;YACtKA,EAAEC,cAAc;QAClB;QACAC,MAAK;OAEJ5B;AAGP,EAAC"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/DropDown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DropDown.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/DropDown.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAqD,MAAM,OAAO,CAAA;AACzF,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAU9D,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,KAAK,EACL,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,EAAE,2BAA2B,CAAA;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,KAAK,CAAC,SAAS,CA+FlB;AA4ED,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EACJ,eAAe,EACf,eAAe,EACf,QAAQ,EACR,QAAgB,EAChB,oBAAoB,GACrB,EAAE;IACD,IAAI,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACf,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,SAAS,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,GAAG,KAAK,CAAC,SAAS,CAgFlB"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/DropDown.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/DropDown.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { mergeRegister } from '@lexical/utils'\nimport { $getSelection } from 'lexical'\nimport { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport React from 'react'\nimport { createPortal } from 'react-dom'\n\nimport type { FloatingToolbarSectionEntry } from '../types.js'\n\nconst baseClass = 'floating-select-toolbar-popup__dropdown-item'\n\ninterface DropDownContextType {\n  registerItem: (ref: React.RefObject<HTMLButtonElement>) => void\n}\n\nconst DropDownContext = React.createContext<DropDownContextType | null>(null)\n\nexport function DropDownItem({\n  children,\n  entry,\n  title,\n}: {\n  children: React.ReactNode\n  entry: FloatingToolbarSectionEntry\n  title?: string\n}): React.ReactNode {\n  const [editor] = useLexicalComposerContext()\n  const [enabled, setEnabled] = useState<boolean>(true)\n  const [active, setActive] = useState<boolean>(false)\n  const [className, setClassName] = useState<string>(baseClass)\n\n  const updateStates = useCallback(() => {\n    editor.getEditorState().read(() => {\n      const selection = $getSelection()\n      if (entry.isActive) {\n        const isActive = entry.isActive({ editor, selection })\n        if (active !== isActive) {\n          setActive(isActive)\n        }\n      }\n      if (entry.isEnabled) {\n        const isEnabled = entry.isEnabled({ editor, selection })\n        if (enabled !== isEnabled) {\n          setEnabled(isEnabled)\n        }\n      }\n    })\n  }, [active, editor, enabled, entry])\n\n  useEffect(() => {\n    updateStates()\n  }, [updateStates])\n\n  useEffect(() => {\n    document.addEventListener('mouseup', updateStates)\n    return () => {\n      document.removeEventListener('mouseup', updateStates)\n    }\n  }, [updateStates])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updateStates()\n      }),\n    )\n  }, [editor, updateStates])\n\n  useEffect(() => {\n    setClassName(\n      [\n        baseClass,\n        enabled === false ? 'disabled' : '',\n        active ? 'active' : '',\n        entry?.key ? `${baseClass}-${entry.key}` : '',\n      ]\n        .filter(Boolean)\n        .join(' '),\n    )\n  }, [enabled, active, className, entry.key])\n\n  const ref = useRef<HTMLButtonElement>(null)\n\n  const dropDownContext = React.useContext(DropDownContext)\n\n  if (dropDownContext === null) {\n    throw new Error('DropDownItem must be used within a DropDown')\n  }\n\n  const { registerItem } = dropDownContext\n\n  useEffect(() => {\n    if (ref?.current != null) {\n      registerItem(ref)\n    }\n  }, [ref, registerItem])\n\n  return (\n    <button\n      className={className}\n      onClick={() => {\n        if (enabled !== false) {\n          entry.onClick({\n            editor,\n            isActive: active,\n          })\n        }\n      }}\n      onMouseDown={(e) => {\n        // This is required for Firefox compatibility. Without it, the dropdown will disappear without the onClick being called.\n        // This only happens in Firefox. Must be something about how Firefox handles focus events differently.\n        e.preventDefault()\n      }}\n      ref={ref}\n      title={title}\n      type=\"button\"\n    >\n      {children}\n    </button>\n  )\n}\n\nfunction DropDownItems({\n  children,\n  dropDownRef,\n  onClose,\n}: {\n  children: React.ReactNode\n  dropDownRef: React.Ref<HTMLDivElement>\n  onClose: () => void\n}): JSX.Element {\n  const [items, setItems] = useState<Array<React.RefObject<HTMLButtonElement>>>()\n  const [highlightedItem, setHighlightedItem] = useState<React.RefObject<HTMLButtonElement>>()\n\n  const registerItem = useCallback(\n    (itemRef: React.RefObject<HTMLButtonElement>) => {\n      setItems((prev) => (prev != null ? [...prev, itemRef] : [itemRef]))\n    },\n    [setItems],\n  )\n\n  const handleKeyDown = (event: React.KeyboardEvent<HTMLDivElement>): void => {\n    if (items == null) return\n\n    const { key } = event\n\n    if (['ArrowDown', 'ArrowUp', 'Escape', 'Tab'].includes(key)) {\n      event.preventDefault()\n    }\n\n    if (key === 'Escape' || key === 'Tab') {\n      onClose()\n    } else if (key === 'ArrowUp') {\n      setHighlightedItem((prev) => {\n        if (prev == null) return items[0]\n        const index = items.indexOf(prev) - 1\n        return items[index === -1 ? items.length - 1 : index]\n      })\n    } else if (key === 'ArrowDown') {\n      setHighlightedItem((prev) => {\n        if (prev == null) return items[0]\n        return items[items.indexOf(prev) + 1]\n      })\n    }\n  }\n\n  const contextValue = useMemo(\n    () => ({\n      registerItem,\n    }),\n    [registerItem],\n  )\n\n  useEffect(() => {\n    if (items != null && highlightedItem == null) {\n      setHighlightedItem(items[0])\n    }\n\n    if (highlightedItem?.current != null) {\n      highlightedItem.current.focus()\n    }\n  }, [items, highlightedItem])\n\n  return (\n    <DropDownContext.Provider value={contextValue}>\n      <div\n        className=\"floating-select-toolbar-popup__dropdown-items\"\n        onKeyDown={handleKeyDown}\n        ref={dropDownRef}\n      >\n        {children}\n      </div>\n    </DropDownContext.Provider>\n  )\n}\n\nexport function DropDown({\n  Icon,\n  buttonAriaLabel,\n  buttonClassName,\n  children,\n  disabled = false,\n  stopCloseOnClickSelf,\n}: {\n  Icon?: React.FC\n  buttonAriaLabel?: string\n  buttonClassName: string\n  children: ReactNode\n  disabled?: boolean\n  stopCloseOnClickSelf?: boolean\n}): React.ReactNode {\n  const dropDownRef = useRef<HTMLDivElement>(null)\n  const buttonRef = useRef<HTMLButtonElement>(null)\n  const [showDropDown, setShowDropDown] = useState(false)\n\n  const handleClose = (): void => {\n    setShowDropDown(false)\n    if (buttonRef?.current != null) {\n      buttonRef.current.focus()\n    }\n  }\n\n  useEffect(() => {\n    const button = buttonRef.current\n    const dropDown = dropDownRef.current\n\n    if (showDropDown && button !== null && dropDown !== null) {\n      const { left, top } = button.getBoundingClientRect()\n      const scrollTopOffset = window.pageYOffset || document.documentElement.scrollTop\n      dropDown.style.top = `${top + scrollTopOffset + button.offsetHeight + 5}px`\n      dropDown.style.left = `${Math.min(left - 5, window.innerWidth - dropDown.offsetWidth - 20)}px`\n    }\n  }, [dropDownRef, buttonRef, showDropDown])\n\n  useEffect(() => {\n    const button = buttonRef.current\n\n    if (button !== null && showDropDown) {\n      const handle = (event: MouseEvent): void => {\n        const { target } = event\n        if (stopCloseOnClickSelf != null) {\n          // eslint-disable-next-line @typescript-eslint/prefer-optional-chain\n          if (dropDownRef.current != null && dropDownRef.current.contains(target as Node)) {\n            return\n          }\n        }\n        if (!button.contains(target as Node)) {\n          setShowDropDown(false)\n        }\n      }\n      document.addEventListener('click', handle)\n\n      return () => {\n        document.removeEventListener('click', handle)\n      }\n    }\n  }, [dropDownRef, buttonRef, showDropDown, stopCloseOnClickSelf])\n\n  return (\n    <React.Fragment>\n      <button\n        aria-label={buttonAriaLabel}\n        className={buttonClassName + (showDropDown ? ' active' : '')}\n        disabled={disabled}\n        onClick={(event) => {\n          event.preventDefault()\n          setShowDropDown(!showDropDown)\n        }}\n        onMouseDown={(e) => {\n          // This fixes a bug where you are unable to click the button if you are in a NESTED editor (editor in blocks field in editor).\n          // Thus only happens if you click on the SVG of the button. Clicking on the outside works. Related issue: https://github.com/payloadcms/payload/issues/4025\n          // TODO: Find out why exactly it happens and why e.preventDefault() on the mouseDown fixes it. Write that down here, or potentially fix a root cause, if there is any.\n          e.preventDefault()\n        }}\n        ref={buttonRef}\n        type=\"button\"\n      >\n        <Icon />\n        <i className=\"floating-select-toolbar-popup__dropdown-caret\" />\n      </button>\n\n      {showDropDown &&\n        createPortal(\n          <DropDownItems dropDownRef={dropDownRef} onClose={handleClose}>\n            {children}\n          </DropDownItems>,\n          document.body,\n        )}\n    </React.Fragment>\n  )\n}\n"],"names":["useLexicalComposerContext","mergeRegister","$getSelection","useCallback","useEffect","useMemo","useRef","useState","React","createPortal","baseClass","DropDownContext","createContext","DropDownItem","children","entry","title","editor","enabled","setEnabled","active","setActive","className","setClassName","updateStates","getEditorState","read","selection","isActive","isEnabled","document","addEventListener","removeEventListener","registerUpdateListener","key","filter","Boolean","join","ref","dropDownContext","useContext","Error","registerItem","current","button","onClick","onMouseDown","e","preventDefault","type","DropDownItems","dropDownRef","onClose","items","setItems","highlightedItem","setHighlightedItem","itemRef","prev","handleKeyDown","event","includes","index","indexOf","length","contextValue","focus","Provider","value","div","onKeyDown","DropDown","Icon","buttonAriaLabel","buttonClassName","disabled","stopCloseOnClickSelf","buttonRef","showDropDown","setShowDropDown","handleClose","dropDown","left","top","getBoundingClientRect","scrollTopOffset","window","pageYOffset","documentElement","scrollTop","style","offsetHeight","Math","min","innerWidth","offsetWidth","handle","target","contains","Fragment","aria-label","i","body"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAG9D,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,YAAY,mCAItB;IACD,UAAU,EAAE,WAAW,CAAA;IACvB,MAAM,EAAE,aAAa,CAAA;IACrB,KAAK,EAAE,2BAA2B,CAAA;CACnC,sBAeA,CAAA;AAED,eAAO,MAAM,eAAe,mEAOzB;IACD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,UAAU,EAAE,WAAW,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,MAAM,EAAE,aAAa,CAAA;IACrB,OAAO,EAAE,2BAA2B,EAAE,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;CACnB,sBAkBA,CAAA"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.js

@@ -1,42 +0,0 @@
-'use client';
-import React from 'react';
-const baseClass = 'floating-select-toolbar-popup__dropdown';
-import { DropDown, DropDownItem } from './DropDown.js';
-import './index.scss';
-export const ToolbarEntry = ({ anchorElem, editor, entry })=>{
-    if (entry.Component) {
-        return entry?.Component && /*#__PURE__*/ React.createElement(entry.Component, {
-            anchorElem: anchorElem,
-            editor: editor,
-            entry: entry,
-            key: entry.key
-        });
-    }
-    return /*#__PURE__*/ React.createElement(DropDownItem, {
-        entry: entry,
-        key: entry.key
-    }, entry?.ChildComponent && /*#__PURE__*/ React.createElement(entry.ChildComponent, null), /*#__PURE__*/ React.createElement("span", {
-        className: "text"
-    }, entry.label));
-};
-export const ToolbarDropdown = ({ Icon, anchorElem, classNames, editor, entries, sectionKey })=>{
-    return /*#__PURE__*/ React.createElement(DropDown, {
-        Icon: Icon,
-        buttonAriaLabel: `${sectionKey} dropdown`,
-        buttonClassName: [
-            baseClass,
-            `${baseClass}-${sectionKey}`,
-            ...classNames || []
-        ].filter(Boolean).join(' '),
-        key: sectionKey
-    }, entries.length && entries.map((entry)=>{
-        return /*#__PURE__*/ React.createElement(ToolbarEntry, {
-            anchorElem: anchorElem,
-            editor: editor,
-            entry: entry,
-            key: entry.key
-        });
-    }));
-};
-
-//# sourceMappingURL=index.js.map

package/dist/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nconst baseClass = 'floating-select-toolbar-popup__dropdown'\n\nimport type { LexicalEditor } from 'lexical'\n\nimport type { FloatingToolbarSectionEntry } from '../types.js'\n\nimport { DropDown, DropDownItem } from './DropDown.js'\nimport './index.scss'\n\nexport const ToolbarEntry = ({\n  anchorElem,\n  editor,\n  entry,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  entry: FloatingToolbarSectionEntry\n}) => {\n  if (entry.Component) {\n    return (\n      entry?.Component && (\n        <entry.Component anchorElem={anchorElem} editor={editor} entry={entry} key={entry.key} />\n      )\n    )\n  }\n\n  return (\n    <DropDownItem entry={entry} key={entry.key}>\n      {entry?.ChildComponent && <entry.ChildComponent />}\n      <span className=\"text\">{entry.label}</span>\n    </DropDownItem>\n  )\n}\n\nexport const ToolbarDropdown = ({\n  Icon,\n  anchorElem,\n  classNames,\n  editor,\n  entries,\n  sectionKey,\n}: {\n  Icon?: React.FC\n  anchorElem: HTMLElement\n  classNames?: string[]\n  editor: LexicalEditor\n  entries: FloatingToolbarSectionEntry[]\n  sectionKey: string\n}) => {\n  return (\n    <DropDown\n      Icon={Icon}\n      buttonAriaLabel={`${sectionKey} dropdown`}\n      buttonClassName={[baseClass, `${baseClass}-${sectionKey}`, ...(classNames || [])]\n        .filter(Boolean)\n        .join(' ')}\n      key={sectionKey}\n    >\n      {entries.length &&\n        entries.map((entry) => {\n          return (\n            <ToolbarEntry anchorElem={anchorElem} editor={editor} entry={entry} key={entry.key} />\n          )\n        })}\n    </DropDown>\n  )\n}\n"],"names":["React","baseClass","DropDown","DropDownItem","ToolbarEntry","anchorElem","editor","entry","Component","key","ChildComponent","span","className","label","ToolbarDropdown","Icon","classNames","entries","sectionKey","buttonAriaLabel","buttonClassName","filter","Boolean","join","length","map"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,WAAW,QAAO;AAEzB,MAAMC,YAAY;AAMlB,SAASC,QAAQ,EAAEC,YAAY,QAAQ,gBAAe;AACtD,OAAO,eAAc;AAErB,OAAO,MAAMC,eAAe,CAAC,EAC3BC,UAAU,EACVC,MAAM,EACNC,KAAK,EAKN;IACC,IAAIA,MAAMC,SAAS,EAAE;QACnB,OACED,OAAOC,2BACL,oBAACD,MAAMC,SAAS;YAACH,YAAYA;YAAYC,QAAQA;YAAQC,OAAOA;YAAOE,KAAKF,MAAME,GAAG;;IAG3F;IAEA,qBACE,oBAACN;QAAaI,OAAOA;QAAOE,KAAKF,MAAME,GAAG;OACvCF,OAAOG,gCAAkB,oBAACH,MAAMG,cAAc,uBAC/C,oBAACC;QAAKC,WAAU;OAAQL,MAAMM,KAAK;AAGzC,EAAC;AAED,OAAO,MAAMC,kBAAkB,CAAC,EAC9BC,IAAI,EACJV,UAAU,EACVW,UAAU,EACVV,MAAM,EACNW,OAAO,EACPC,UAAU,EAQX;IACC,qBACE,oBAAChB;QACCa,MAAMA;QACNI,iBAAiB,CAAC,EAAED,WAAW,SAAS,CAAC;QACzCE,iBAAiB;YAACnB;YAAW,CAAC,EAAEA,UAAU,CAAC,EAAEiB,WAAW,CAAC;eAAMF,cAAc,EAAE;SAAE,CAC9EK,MAAM,CAACC,SACPC,IAAI,CAAC;QACRd,KAAKS;OAEJD,QAAQO,MAAM,IACbP,QAAQQ,GAAG,CAAC,CAAClB;QACX,qBACE,oBAACH;YAAaC,YAAYA;YAAYC,QAAQA;YAAQC,OAAOA;YAAOE,KAAKF,MAAME,GAAG;;IAEtF;AAGR,EAAC"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/index.tsx"],"names":[],"mappings":";AAuBA,OAAO,cAAc,CAAA;AA2VrB,wBAAgB,2BAA2B,CAAC,EAC1C,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,GAAG,CAAC,OAAO,GAAG,IAAI,CAGrB"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  $isTextNode,\n  COMMAND_PRIORITY_LOW,\n  SELECTION_CHANGE_COMMAND,\n} from 'lexical'\nimport { useCallback, useEffect, useRef, useState } from 'react'\nimport * as React from 'react'\nimport { createPortal } from 'react-dom'\n\nimport type { FloatingToolbarSection, FloatingToolbarSectionEntry } from './types.js'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\nimport { getDOMRangeRect } from '../../utils/getDOMRangeRect.js'\nimport { setFloatingElemPosition } from '../../utils/setFloatingElemPosition.js'\nimport { ToolbarButton } from './ToolbarButton/index.js'\nimport { ToolbarDropdown } from './ToolbarDropdown/index.js'\nimport './index.scss'\n\nfunction ButtonSectionEntry({\n  anchorElem,\n  editor,\n  entry,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  entry: FloatingToolbarSectionEntry\n}): React.ReactNode {\n  if (entry.Component) {\n    return (\n      entry?.Component && (\n        <entry.Component anchorElem={anchorElem} editor={editor} entry={entry} key={entry.key} />\n      )\n    )\n  }\n\n  return (\n    <ToolbarButton entry={entry} key={entry.key}>\n      {entry?.ChildComponent && <entry.ChildComponent />}\n    </ToolbarButton>\n  )\n}\n\nfunction ToolbarSection({\n  anchorElem,\n  editor,\n  index,\n  section,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  index: number\n  section: FloatingToolbarSection\n}): React.ReactNode {\n  const { editorConfig } = useEditorConfigContext()\n\n  const Icon =\n    section?.type === 'dropdown' && section.entries.length && section.ChildComponent\n      ? section.ChildComponent\n      : null\n\n  return (\n    <div\n      className={`floating-select-toolbar-popup__section floating-select-toolbar-popup__section-${section.key}`}\n      key={section.key}\n    >\n      {section.type === 'dropdown' &&\n        section.entries.length &&\n        (Icon ? (\n          <ToolbarDropdown\n            Icon={Icon}\n            anchorElem={anchorElem}\n            editor={editor}\n            entries={section.entries}\n            sectionKey={section.key}\n          />\n        ) : (\n          <ToolbarDropdown\n            anchorElem={anchorElem}\n            editor={editor}\n            entries={section.entries}\n            sectionKey={section.key}\n          />\n        ))}\n      {section.type === 'buttons' &&\n        section.entries.length &&\n        section.entries.map((entry) => {\n          return (\n            <ButtonSectionEntry\n              anchorElem={anchorElem}\n              editor={editor}\n              entry={entry}\n              key={entry.key}\n            />\n          )\n        })}\n      {index < editorConfig.features.floatingSelectToolbar?.sections.length - 1 && (\n        <div className=\"divider\" />\n      )}\n    </div>\n  )\n}\n\nfunction FloatingSelectToolbar({\n  anchorElem,\n  editor,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n}): React.ReactNode {\n  const floatingToolbarRef = useRef<HTMLDivElement | null>(null)\n  const caretRef = useRef<HTMLDivElement | null>(null)\n\n  const { editorConfig } = useEditorConfigContext()\n\n  const closeFloatingToolbar = useCallback(() => {\n    if (floatingToolbarRef?.current) {\n      const isOpacityZero = floatingToolbarRef.current.style.opacity === '0'\n      const isPointerEventsNone = floatingToolbarRef.current.style.pointerEvents === 'none'\n\n      if (!isOpacityZero) {\n        floatingToolbarRef.current.style.opacity = '0'\n      }\n      if (!isPointerEventsNone) {\n        floatingToolbarRef.current.style.pointerEvents = 'none'\n      }\n    }\n  }, [floatingToolbarRef])\n\n  const mouseMoveListener = useCallback(\n    (e: MouseEvent) => {\n      if (floatingToolbarRef?.current && (e.buttons === 1 || e.buttons === 3)) {\n        const isOpacityZero = floatingToolbarRef.current.style.opacity === '0'\n        const isPointerEventsNone = floatingToolbarRef.current.style.pointerEvents === 'none'\n        if (!isOpacityZero || !isPointerEventsNone) {\n          // Check if the mouse is not over the popup\n          const x = e.clientX\n          const y = e.clientY\n          const elementUnderMouse = document.elementFromPoint(x, y)\n          if (!floatingToolbarRef.current.contains(elementUnderMouse)) {\n            // Mouse is not over the target element => not a normal click, but probably a drag\n            closeFloatingToolbar()\n          }\n        }\n      }\n    },\n    [closeFloatingToolbar],\n  )\n\n  const mouseUpListener = useCallback(() => {\n    if (floatingToolbarRef?.current) {\n      if (floatingToolbarRef.current.style.opacity !== '1') {\n        floatingToolbarRef.current.style.opacity = '1'\n      }\n      if (floatingToolbarRef.current.style.pointerEvents !== 'auto') {\n        floatingToolbarRef.current.style.pointerEvents = 'auto'\n      }\n    }\n  }, [floatingToolbarRef])\n\n  useEffect(() => {\n    document.addEventListener('mousemove', mouseMoveListener)\n    document.addEventListener('mouseup', mouseUpListener)\n\n    return () => {\n      document.removeEventListener('mousemove', mouseMoveListener)\n      document.removeEventListener('mouseup', mouseUpListener)\n    }\n  }, [floatingToolbarRef, mouseMoveListener, mouseUpListener])\n\n  const updateTextFormatFloatingToolbar = useCallback(() => {\n    const selection = $getSelection()\n\n    const nativeSelection = window.getSelection()\n\n    if (floatingToolbarRef.current === null) {\n      return\n    }\n\n    const rootElement = editor.getRootElement()\n    if (\n      selection !== null &&\n      nativeSelection !== null &&\n      !nativeSelection.isCollapsed &&\n      rootElement !== null &&\n      rootElement.contains(nativeSelection.anchorNode)\n    ) {\n      const rangeRect = getDOMRangeRect(nativeSelection, rootElement)\n\n      // Position floating toolbar\n      const offsetIfFlipped = setFloatingElemPosition(\n        rangeRect, // selection to position around\n        floatingToolbarRef.current, // what to position\n        anchorElem, // anchor elem\n        'center',\n      )\n\n      // Position caret\n      if (caretRef.current) {\n        setFloatingElemPosition(\n          rangeRect, // selection to position around\n          caretRef.current, // what to position\n          floatingToolbarRef.current, // anchor elem\n          'center',\n          10,\n          5,\n          true,\n          offsetIfFlipped,\n        )\n      }\n    }\n  }, [editor, anchorElem])\n\n  useEffect(() => {\n    const scrollerElem = anchorElem.parentElement\n\n    const update = () => {\n      editor.getEditorState().read(() => {\n        updateTextFormatFloatingToolbar()\n      })\n    }\n\n    window.addEventListener('resize', update)\n    if (scrollerElem) {\n      scrollerElem.addEventListener('scroll', update)\n    }\n\n    return () => {\n      window.removeEventListener('resize', update)\n      if (scrollerElem) {\n        scrollerElem.removeEventListener('scroll', update)\n      }\n    }\n  }, [editor, updateTextFormatFloatingToolbar, anchorElem])\n\n  useEffect(() => {\n    editor.getEditorState().read(() => {\n      updateTextFormatFloatingToolbar()\n    })\n    return mergeRegister(\n      editor.registerUpdateListener(({ editorState }) => {\n        editorState.read(() => {\n          updateTextFormatFloatingToolbar()\n        })\n      }),\n\n      editor.registerCommand(\n        SELECTION_CHANGE_COMMAND,\n        () => {\n          updateTextFormatFloatingToolbar()\n          return false\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, updateTextFormatFloatingToolbar])\n\n  return (\n    <div className=\"floating-select-toolbar-popup\" ref={floatingToolbarRef}>\n      <div className=\"caret\" ref={caretRef} />\n      {editor.isEditable() && (\n        <React.Fragment>\n          {editorConfig?.features &&\n            editorConfig.features?.floatingSelectToolbar?.sections.map((section, i) => {\n              return (\n                <ToolbarSection\n                  anchorElem={anchorElem}\n                  editor={editor}\n                  index={i}\n                  key={section.key}\n                  section={section}\n                />\n              )\n            })}\n        </React.Fragment>\n      )}\n    </div>\n  )\n}\n\nfunction useFloatingTextFormatToolbar(\n  editor: LexicalEditor,\n  anchorElem: HTMLElement,\n): JSX.Element | null {\n  const [isText, setIsText] = useState(false)\n\n  const updatePopup = useCallback(() => {\n    editor.getEditorState().read(() => {\n      // Should not to pop up the floating toolbar when using IME input\n      if (editor.isComposing()) {\n        return\n      }\n      const selection = $getSelection()\n      const nativeSelection = window.getSelection()\n      const rootElement = editor.getRootElement()\n\n      if (\n        nativeSelection !== null &&\n        (!$isRangeSelection(selection) ||\n          rootElement === null ||\n          !rootElement.contains(nativeSelection.anchorNode))\n      ) {\n        setIsText(false)\n        return\n      }\n\n      if (!$isRangeSelection(selection)) {\n        return\n      }\n\n      if (selection.getTextContent() !== '') {\n        const nodes = selection.getNodes()\n        let foundNodeWithText = false\n        for (const node of nodes) {\n          if ($isTextNode(node)) {\n            setIsText(true)\n            foundNodeWithText = true\n            break\n          }\n        }\n        if (!foundNodeWithText) {\n          setIsText(false)\n        }\n      } else {\n        setIsText(false)\n      }\n\n      const rawTextContent = selection.getTextContent().replace(/\\n/g, '')\n      if (!selection.isCollapsed() && rawTextContent === '') {\n        setIsText(false)\n        return\n      }\n    })\n  }, [editor])\n\n  useEffect(() => {\n    document.addEventListener('selectionchange', updatePopup)\n    document.addEventListener('mouseup', updatePopup)\n    return () => {\n      document.removeEventListener('selectionchange', updatePopup)\n      document.removeEventListener('mouseup', updatePopup)\n    }\n  }, [updatePopup])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updatePopup()\n      }),\n      editor.registerRootListener(() => {\n        if (editor.getRootElement() === null) {\n          setIsText(false)\n        }\n      }),\n    )\n  }, [editor, updatePopup])\n\n  if (!isText) {\n    return null\n  }\n\n  return createPortal(<FloatingSelectToolbar anchorElem={anchorElem} editor={editor} />, anchorElem)\n}\n\nexport function FloatingSelectToolbarPlugin({\n  anchorElem = document.body,\n}: {\n  anchorElem?: HTMLElement\n}): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n  return useFloatingTextFormatToolbar(editor, anchorElem)\n}\n"],"names":["useLexicalComposerContext","mergeRegister","$getSelection","$isRangeSelection","$isTextNode","COMMAND_PRIORITY_LOW","SELECTION_CHANGE_COMMAND","useCallback","useEffect","useRef","useState","React","createPortal","useEditorConfigContext","getDOMRangeRect","setFloatingElemPosition","ToolbarButton","ToolbarDropdown","ButtonSectionEntry","anchorElem","editor","entry","Component","key","ChildComponent","ToolbarSection","index","section","editorConfig","Icon","type","entries","length","div","className","sectionKey","map","features","floatingSelectToolbar","sections","FloatingSelectToolbar","floatingToolbarRef","caretRef","closeFloatingToolbar","current","isOpacityZero","style","opacity","isPointerEventsNone","pointerEvents","mouseMoveListener","e","buttons","x","clientX","y","clientY","elementUnderMouse","document","elementFromPoint","contains","mouseUpListener","addEventListener","removeEventListener","updateTextFormatFloatingToolbar","selection","nativeSelection","window","getSelection","rootElement","getRootElement","isCollapsed","anchorNode","rangeRect","offsetIfFlipped","scrollerElem","parentElement","update","getEditorState","read","registerUpdateListener","editorState","registerCommand","ref","isEditable","Fragment","i","useFloatingTextFormatToolbar","isText","setIsText","updatePopup","isComposing","getTextContent","nodes","getNodes","foundNodeWithText","node","rawTextContent","replace","registerRootListener","FloatingSelectToolbarPlugin","body"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/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,sBAAsB,GAC9B;IACE,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,OAAO,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC3C,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;CACjB,GACD;IACE,OAAO,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC3C,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,MAAM,MAAM,2BAA2B,GAAG;IACxC,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,KAAK,EAAE,2BAA2B,CAAA;KACnC,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,gFAAgF;IAChF,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"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/types.ts"],"sourcesContent":["import type { BaseSelection, LexicalEditor } from 'lexical'\nimport type React from 'react'\n\nexport type FloatingToolbarSection =\n  | {\n      ChildComponent?: React.FC\n      entries: Array<FloatingToolbarSectionEntry>\n      key: string\n      order?: number\n      type: 'dropdown'\n    }\n  | {\n      entries: Array<FloatingToolbarSectionEntry>\n      key: string\n      order?: number\n      type: 'buttons'\n    }\n\nexport type FloatingToolbarSectionEntry = {\n  ChildComponent?: React.FC\n  /** Use component to ignore the children and onClick properties. It does not use the default, pre-defined format Button component */\n  Component?: React.FC<{\n    anchorElem: HTMLElement\n    editor: LexicalEditor\n    entry: FloatingToolbarSectionEntry\n  }>\n  isActive?: ({ editor, selection }: { editor: LexicalEditor; selection: BaseSelection }) => boolean\n  isEnabled?: ({\n    editor,\n    selection,\n  }: {\n    editor: LexicalEditor\n    selection: BaseSelection\n  }) => boolean\n  key: string\n  /** The label is displayed as text if the entry is part of a dropdown section */\n  label?: string\n  onClick?: ({ editor, isActive }: { editor: LexicalEditor; isActive: boolean }) => void\n  order?: number\n}\n"],"names":[],"rangeMappings":"","mappings":"AAkBA,WAqBC"}