@payloadcms/richtext-lexical 3.0.0-beta.52 → 3.0.0-beta.53

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\nimport type {\n  EditorConfig as LexicalEditorConfig,\n  SerializedEditorState,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport { withMergedProps } from '@payloadcms/ui/elements/withMergedProps'\nimport { fileURLToPath } from 'node:url'\nimport path from 'path'\nimport {\n  afterChangeTraverseFields,\n  afterReadTraverseFields,\n  beforeChangeTraverseFields,\n  beforeValidateTraverseFields,\n  getDependencies,\n  withNullableJSONSchemaType,\n} from 'payload'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from './field/features/types.js'\nimport type { SanitizedServerEditorConfig } from './field/lexical/config/types.js'\nimport type {\n  AdapterProps,\n  LexicalEditorProps,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from './types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { RichTextCell, RichTextField } from './exports/client/index.js'\nimport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n} from './field/lexical/config/server/default.js'\nimport { loadFeatures } from './field/lexical/config/server/loader.js'\nimport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\nimport { cloneDeep } from './field/lexical/utils/cloneDeep.js'\nimport { getGenerateComponentMap } from './generateComponentMap.js'\nimport { getGenerateSchemaMap } from './generateSchemaMap.js'\nimport { i18n } from './i18n.js'\nimport { populateLexicalPopulationPromises } from './populateGraphQL/populateLexicalPopulationPromises.js'\nimport { recurseNodeTree } from './recurseNodeTree.js'\nimport { richTextValidateHOC } from './validate/index.js'\n\nlet defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig = null\n\nconst filename = fileURLToPath(import.meta.url)\nconst dirname = path.dirname(filename)\n\nexport function lexicalEditor(props?: LexicalEditorProps): LexicalRichTextAdapterProvider {\n  return async ({ config, isRoot }) => {\n    if (process.env.NODE_ENV !== 'production') {\n      const resolvedDependencies = await getDependencies(dirname, [\n        'lexical',\n        '@lexical/headless',\n        '@lexical/link',\n        '@lexical/list',\n        '@lexical/mark',\n        '@lexical/markdown',\n        '@lexical/react',\n        '@lexical/rich-text',\n        '@lexical/selection',\n        '@lexical/utils',\n      ])\n\n      // Go through each resolved dependency. If any dependency has a mismatching version, throw an error\n      const foundVersions: {\n        [version: string]: string\n      } = {}\n      for (const [_pkg, { version }] of resolvedDependencies.resolved) {\n        if (!Object.keys(foundVersions).includes(version)) {\n          foundVersions[version] = _pkg\n        }\n      }\n      if (Object.keys(foundVersions).length !== 1) {\n        const formattedVersionsWithPackageNameString = Object.entries(foundVersions)\n          .map(([version, pkg]) => `${pkg}@${version}`)\n          .join(', ')\n\n        throw new Error(\n          `Mismatching lexical dependency versions found: ${formattedVersionsWithPackageNameString}. All lexical and @lexical/* packages must have the same version.`,\n        )\n      }\n    }\n\n    let features: FeatureProviderServer<unknown, unknown>[] = []\n    let resolvedFeatureMap: ResolvedServerFeatureMap\n\n    let finalSanitizedEditorConfig: SanitizedServerEditorConfig // For server only\n    if (!props || (!props.features && !props.lexical)) {\n      if (!defaultSanitizedServerEditorConfig) {\n        defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(\n          defaultEditorConfig,\n          config,\n        )\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)\n\n      resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap\n    } else {\n      const rootEditor = config.editor\n      let rootEditorFeatures: FeatureProviderServer<unknown, unknown>[] = []\n      if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n        rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n      }\n\n      features =\n        props.features && typeof props.features === 'function'\n          ? props.features({\n              defaultFeatures: cloneDeep(defaultEditorFeatures),\n              rootFeatures: rootEditorFeatures,\n            })\n          : (props.features as FeatureProviderServer<unknown, unknown>[])\n      if (!features) {\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      const lexical: LexicalEditorConfig = props.lexical\n\n      resolvedFeatureMap = await loadFeatures({\n        config,\n        isRoot,\n        unSanitizedEditorConfig: {\n          features,\n          lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        },\n      })\n\n      finalSanitizedEditorConfig = {\n        features: sanitizeServerFeatures(resolvedFeatureMap),\n        lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        resolvedFeatureMap,\n      }\n    }\n\n    const featureI18n = finalSanitizedEditorConfig.features.i18n\n    for (const lang in i18n) {\n      if (!featureI18n[lang]) {\n        featureI18n[lang] = {\n          lexical: {},\n        }\n      }\n\n      featureI18n[lang].lexical.general = i18n[lang]\n    }\n\n    return {\n      CellComponent: withMergedProps({\n        Component: RichTextCell,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      FieldComponent: withMergedProps({\n        Component: RichTextField,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      editorConfig: finalSanitizedEditorConfig,\n      features,\n      generateComponentMap: getGenerateComponentMap({\n        resolvedFeatureMap,\n      }),\n      generateSchemaMap: getGenerateSchemaMap({\n        resolvedFeatureMap,\n      }),\n      graphQLPopulationPromises({\n        context,\n        currentDepth,\n        depth,\n        draft,\n        field,\n        fieldPromises,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        req,\n        showHiddenFields,\n        siblingDoc,\n      }) {\n        // check if there are any features with nodes which have populationPromises for this field\n        if (finalSanitizedEditorConfig?.features?.graphQLPopulationPromises?.size) {\n          populateLexicalPopulationPromises({\n            context,\n            currentDepth: currentDepth ?? 0,\n            depth,\n            draft,\n            editorPopulationPromises: finalSanitizedEditorConfig.features.graphQLPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            overrideAccess,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      },\n      hooks: {\n        afterChange: [\n          async ({\n            collection,\n            context: _context,\n            global,\n            operation,\n            path,\n            req,\n            schemaPath,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.afterChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n            const context: any = _context\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            /**\n             * Get the originalNodeIDMap from the beforeValidate hook, which is always run before this hook.\n             */\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = context?.internal?.richText?.[path.join('.')]?.originalNodeIDMap\n\n            if (!originalNodeIDMap || !Object.keys(originalNodeIDMap).length || !value) {\n              return value\n            }\n\n            recurseNodeTree({\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const afterChangeHooks = finalSanitizedEditorConfig.features.hooks.afterChange\n              if (afterChangeHooks?.has(node.type)) {\n                for (const hook of afterChangeHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(afterChange) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n\n                if (subFields?.length) {\n                  await afterChangeTraverseFields({\n                    collection,\n                    context,\n                    data: originalData,\n                    doc: data,\n                    fields: subFields,\n                    global,\n                    operation,\n                    path,\n                    previousDoc: data,\n                    previousSiblingDoc: { ...data },\n                    req,\n                    schemaPath,\n                    siblingData: originalData || {},\n                    siblingDoc: { ...data },\n                  })\n                }\n              }\n            }\n            return value\n          },\n        ],\n        afterRead: [\n          /**\n           * afterRead hooks do not receive the originalNode. Thus, they can run on all nodes, not just nodes with an ID.\n           */\n          async ({\n            collection,\n            context: context,\n            currentDepth,\n            depth,\n            draft,\n            fallbackLocale,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            global,\n            locale,\n            overrideAccess,\n            path,\n            populationPromises,\n            req,\n            schemaPath,\n            showHiddenFields,\n            triggerAccessControl,\n            triggerHooks,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.afterRead.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n            const flattenedNodes: SerializedLexicalNode[] = []\n\n            recurseNodeTree({\n              flattenedNodes,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            for (let node of flattenedNodes) {\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({\n                    context,\n                    currentDepth,\n                    depth,\n                    draft,\n                    fallbackLocale,\n                    fieldPromises,\n                    findMany,\n                    flattenLocales,\n                    locale,\n                    node,\n                    overrideAccess,\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    populationPromises,\n                    req,\n                    showHiddenFields,\n                    triggerAccessControl,\n                    triggerHooks,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n\n                if (subFields?.length) {\n                  afterReadTraverseFields({\n                    collection,\n                    context,\n                    currentDepth,\n                    depth,\n                    doc: data,\n                    draft,\n                    fallbackLocale,\n                    fieldPromises,\n                    fields: subFields,\n                    findMany,\n                    flattenLocales,\n                    global,\n                    locale,\n                    overrideAccess,\n                    path,\n                    populationPromises,\n                    req,\n                    schemaPath,\n                    showHiddenFields,\n                    siblingDoc: data,\n                    triggerAccessControl,\n                    triggerHooks,\n                  })\n                }\n              }\n            }\n\n            return value\n          },\n        ],\n        beforeChange: [\n          async ({\n            collection,\n            context: _context,\n            duplicate,\n            errors,\n            field,\n            global,\n            mergeLocaleActions,\n            operation,\n            path,\n            req,\n            schemaPath,\n            siblingData,\n            siblingDocWithLocales,\n            skipValidation,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.beforeChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n\n            const context: any = _context\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            /**\n             * Get the originalNodeIDMap from the beforeValidate hook, which is always run before this hook.\n             */\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = context?.internal?.richText?.[path.join('.')]?.originalNodeIDMap\n\n            if (!originalNodeIDMap || !Object.keys(originalNodeIDMap).length || !value) {\n              return value\n            }\n\n            const originalNodeWithLocalesIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            recurseNodeTree({\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (siblingDocWithLocales?.[field.name]) {\n              recurseNodeTree({\n                nodeIDMap: originalNodeWithLocalesIDMap,\n                nodes:\n                  (siblingDocWithLocales[field.name] as SerializedEditorState)?.root?.children ??\n                  [],\n              })\n            }\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const beforeChangeHooks = finalSanitizedEditorConfig.features.hooks.beforeChange\n              if (beforeChangeHooks?.has(node.type)) {\n                for (const hook of beforeChangeHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(beforeChange) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    duplicate,\n                    errors,\n                    mergeLocaleActions,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    originalNodeWithLocales: originalNodeWithLocalesIDMap[id],\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                    skipValidation,\n                  })\n                }\n              }\n\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n                const originalDataWithLocales = subFieldDataFn({\n                  node: originalNodeWithLocalesIDMap[id],\n                  req,\n                })\n\n                if (subFields?.length) {\n                  await beforeChangeTraverseFields({\n                    id,\n                    collection,\n                    context,\n                    data,\n                    doc: originalData,\n                    docWithLocales: originalDataWithLocales ?? {},\n                    duplicate,\n                    errors,\n                    fields: subFields,\n                    global,\n                    mergeLocaleActions,\n                    operation,\n                    path,\n                    req,\n                    schemaPath,\n                    siblingData: data,\n                    siblingDoc: originalData,\n                    siblingDocWithLocales: originalDataWithLocales ?? {},\n                    skipValidation,\n                  })\n                }\n              }\n            }\n\n            /**\n             * within the beforeChange hook, id's may be re-generated.\n             * Example:\n             * 1. Seed data contains IDs for block feature blocks.\n             * 2. Those are used in beforeValidate\n             * 3. in beforeChange, those IDs are regenerated, because you cannot provide IDs during document creation. See baseIDField beforeChange hook for reasoning\n             * 4. Thus, in order for all post-beforeChange hooks to receive the correct ID, we need to update the originalNodeIDMap with the new ID's, by regenerating the nodeIDMap.\n             * The reason this is not generated for every hook, is to save on performance. We know we only really have to generate it in beforeValidate, which is the first hook,\n             * and in beforeChange, which is where modifications to the provided IDs can occur.\n             */\n            const newOriginalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            const previousValue = siblingData[field.name]\n\n            recurseNodeTree({\n              nodeIDMap: newOriginalNodeIDMap,\n              nodes: (previousValue as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (!context.internal) {\n              // Add to context, for other hooks to use\n              context.internal = {}\n            }\n            if (!context.internal.richText) {\n              context.internal.richText = {}\n            }\n            context.internal.richText[path.join('.')] = {\n              originalNodeIDMap: newOriginalNodeIDMap,\n            }\n\n            return value\n          },\n        ],\n        beforeValidate: [\n          async ({\n            collection,\n            context,\n            global,\n            operation,\n            overrideAccess,\n            path,\n            previousValue,\n            req,\n            schemaPath,\n            value,\n          }) => {\n            // return value if there are NO hooks\n            if (\n              !finalSanitizedEditorConfig.features.hooks.beforeValidate.size &&\n              !finalSanitizedEditorConfig.features.hooks.afterChange.size &&\n              !finalSanitizedEditorConfig.features.hooks.beforeChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n\n            /**\n             * beforeValidate is the first field hook which runs. This is where we can create the node map, which can then be used in the other hooks.\n             *\n             */\n\n            /**\n             * flattenedNodes contains all nodes in the editor, in the order they appear in the editor. They will be used for the following hooks:\n             * - afterRead\n             *\n             * The other hooks require nodes to have IDs, which is why those are ran only from the nodeIDMap. They require IDs because they have both doc/siblingDoc and data/siblingData, and\n             * thus require a reliable way to match new node data to old node data. Given that node positions can change in between hooks, this is only reliably possible for nodes which are saved with\n             * an ID.\n             */\n            //const flattenedNodes: SerializedLexicalNode[] = []\n\n            /**\n             * Only nodes with id's (so, nodes with hooks added to them) will be added to the nodeIDMap. They will be used for the following hooks:\n             * - afterChange\n             * - beforeChange\n             * - beforeValidate\n             * - beforeDuplicate\n             *\n             * Other hooks are handled by the flattenedNodes. All nodes in the nodeIDMap are part of flattenedNodes.\n             */\n\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            recurseNodeTree({\n              nodeIDMap: originalNodeIDMap,\n              nodes: (previousValue as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (!context.internal) {\n              // Add to context, for other hooks to use\n              context.internal = {}\n            }\n            if (!(context as any).internal.richText) {\n              ;(context as any).internal.richText = {}\n            }\n            ;(context as any).internal.richText[path.join('.')] = {\n              originalNodeIDMap,\n            }\n\n            /**\n             * Now that the maps for all hooks are set up, we can run the validate hook\n             */\n            if (!finalSanitizedEditorConfig.features.hooks.beforeValidate.size) {\n              return value\n            }\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n            recurseNodeTree({\n              //flattenedNodes,\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const beforeValidateHooks = finalSanitizedEditorConfig.features.hooks.beforeValidate\n              if (beforeValidateHooks?.has(node.type)) {\n                for (const hook of beforeValidateHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(beforeValidate) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    overrideAccess,\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n\n                if (subFields?.length) {\n                  await beforeValidateTraverseFields({\n                    id,\n                    collection,\n                    context,\n                    data,\n                    doc: originalData,\n                    fields: subFields,\n                    global,\n                    operation,\n                    overrideAccess,\n                    path,\n                    req,\n                    schemaPath,\n                    siblingData: data,\n                    siblingDoc: originalData,\n                  })\n                }\n              }\n            }\n\n            return value\n          },\n        ],\n      },\n      i18n: featureI18n,\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      validate: richTextValidateHOC({\n        editorConfig: finalSanitizedEditorConfig,\n      }),\n    }\n  }\n}\n\nexport { AlignFeature } from './field/features/align/feature.server.js'\nexport { BlockquoteFeature } from './field/features/blockquote/feature.server.js'\nexport { BlocksFeature, type BlocksFeatureProps } from './field/features/blocks/feature.server.js'\nexport {\n  $createBlockNode,\n  $isBlockNode,\n  type BlockFields,\n  BlockNode,\n  type SerializedBlockNode,\n} from './field/features/blocks/nodes/BlocksNode.js'\n\nexport { LinebreakHTMLConverter } from './field/features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './field/features/converters/html/converter/converters/paragraph.js'\nexport { TextHTMLConverter } from './field/features/converters/html/converter/converters/text.js'\n\nexport { defaultHTMLConverters } from './field/features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './field/features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './field/features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './field/features/converters/html/feature.server.js'\nexport {\n  consolidateHTMLConverters,\n  lexicalHTML,\n} from './field/features/converters/html/field/index.js'\nexport { TestRecorderFeature } from './field/features/debug/testRecorder/feature.server.js'\nexport { TreeViewFeature } from './field/features/debug/treeView/feature.server.js'\nexport { BoldFeature } from './field/features/format/bold/feature.server.js'\nexport { InlineCodeFeature } from './field/features/format/inlineCode/feature.server.js'\n\nexport { ItalicFeature } from './field/features/format/italic/feature.server.js'\nexport { StrikethroughFeature } from './field/features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './field/features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './field/features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './field/features/format/underline/feature.server.js'\nexport {\n  HeadingFeature,\n  type HeadingFeatureProps,\n} from './field/features/heading/feature.server.js'\nexport { HorizontalRuleFeature } from './field/features/horizontalRule/feature.server.js'\n\nexport { IndentFeature } from './field/features/indent/feature.server.js'\nexport { LinkFeature, type LinkFeatureServerProps } from './field/features/link/feature.server.js'\n\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './field/features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './field/features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './field/features/link/nodes/types.js'\nexport { ChecklistFeature } from './field/features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './field/features/lists/orderedList/feature.server.js'\nexport { UnorderedListFeature } from './field/features/lists/unorderedList/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './field/features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './field/features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './field/features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './field/features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './field/features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './field/features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './field/features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './field/features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\nexport { SlateUploadConverter } from './field/features/migrations/slateToLexical/converter/converters/upload/index.js'\nexport { defaultSlateConverters } from './field/features/migrations/slateToLexical/converter/defaultConverters.js'\n\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './field/features/migrations/slateToLexical/converter/index.js'\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './field/features/migrations/slateToLexical/converter/types.js'\nexport { SlateToLexicalFeature } from './field/features/migrations/slateToLexical/feature.server.js'\n\nexport { ParagraphFeature } from './field/features/paragraph/feature.server.js'\nexport {\n  RelationshipFeature,\n  type RelationshipFeatureProps,\n} from './field/features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './field/features/relationship/nodes/RelationshipNode.js'\n\nexport { FixedToolbarFeature } from './field/features/toolbars/fixed/feature.server.js'\nexport { InlineToolbarFeature } from './field/features/toolbars/inline/feature.server.js'\n\nexport type { ToolbarGroup, ToolbarGroupItem } from './field/features/toolbars/types.js'\nexport { createNode } from './field/features/typeUtilities.js'\nexport type {\n  AfterChangeNodeHook,\n  AfterChangeNodeHookArgs,\n  AfterReadNodeHook,\n  AfterReadNodeHookArgs,\n  BaseNodeHookArgs,\n  BeforeChangeNodeHook,\n  BeforeChangeNodeHookArgs,\n  BeforeValidateNodeHook,\n  BeforeValidateNodeHookArgs,\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  NodeValidation,\n  NodeWithHooks,\n  PluginComponent,\n  PluginComponentWithAnchor,\n  PopulationPromise,\n  ResolvedClientFeature,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeature,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedPlugin,\n  SanitizedServerFeatures,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from './field/features/types.js'\n\nexport { UploadFeature } from './field/features/upload/feature.server.js'\n\nexport type { UploadFeatureProps } from './field/features/upload/feature.server.js'\nexport {\n  $createUploadNode,\n  $isUploadNode,\n  type SerializedUploadNode,\n  type UploadData,\n  UploadNode,\n} from './field/features/upload/nodes/UploadNode.js'\n\nexport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultEditorLexicalConfig,\n} from './field/lexical/config/server/default.js'\nexport {\n  loadFeatures,\n  sortFeaturesForOptimalLoading,\n} from './field/lexical/config/server/loader.js'\n\nexport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './field/lexical/config/server/sanitize.js'\nexport type {\n  ClientEditorConfig,\n  SanitizedClientEditorConfig,\n  SanitizedServerEditorConfig,\n  ServerEditorConfig,\n} from './field/lexical/config/types.js'\n\nexport { getEnabledNodes } from './field/lexical/nodes/index.js'\nexport { ENABLE_SLASH_MENU_COMMAND } from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type { AdapterProps }\n\nexport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from './field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\n\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'\n\nexport { sanitizeUrl, validateUrl } from './field/lexical/utils/url.js'\nexport { defaultRichTextValue } from './populateGraphQL/defaultValue.js'\n\nexport type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n"],"names":["withMergedProps","fileURLToPath","path","afterChangeTraverseFields","afterReadTraverseFields","beforeChangeTraverseFields","beforeValidateTraverseFields","getDependencies","withNullableJSONSchemaType","RichTextCell","RichTextField","defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerEditorConfig","sanitizeServerFeatures","cloneDeep","getGenerateComponentMap","getGenerateSchemaMap","i18n","populateLexicalPopulationPromises","recurseNodeTree","richTextValidateHOC","defaultSanitizedServerEditorConfig","filename","url","dirname","lexicalEditor","props","config","isRoot","process","env","NODE_ENV","resolvedDependencies","foundVersions","_pkg","version","resolved","Object","keys","includes","length","formattedVersionsWithPackageNameString","entries","map","pkg","join","Error","features","resolvedFeatureMap","finalSanitizedEditorConfig","lexical","rootEditor","editor","rootEditorFeatures","defaultFeatures","rootFeatures","unSanitizedEditorConfig","featureI18n","lang","general","CellComponent","Component","toMergeIntoProps","admin","lexicalEditorConfig","FieldComponent","editorConfig","generateComponentMap","generateSchemaMap","graphQLPopulationPromises","context","currentDepth","depth","draft","field","fieldPromises","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","size","editorPopulationPromises","hooks","afterChange","collection","_context","global","operation","schemaPath","value","getSubFields","nodeIDMap","originalNodeIDMap","internal","richText","nodes","root","children","id","node","afterChangeHooks","has","type","hook","get","console","warn","originalNode","parentRichTextFieldPath","parentRichTextFieldSchemaPath","subFieldFn","subFieldDataFn","getSubFieldsData","subFields","data","originalData","doc","fields","previousDoc","previousSiblingDoc","siblingData","afterRead","fallbackLocale","locale","triggerAccessControl","triggerHooks","flattenedNodes","afterReadHooks","beforeChange","duplicate","errors","mergeLocaleActions","siblingDocWithLocales","skipValidation","originalNodeWithLocalesIDMap","name","beforeChangeHooks","originalNodeWithLocales","originalDataWithLocales","docWithLocales","newOriginalNodeIDMap","previousValue","beforeValidate","beforeValidateHooks","outputSchema","collectionIDFieldTypes","interfaceNameDefinitions","isRequired","properties","additionalProperties","items","required","direction","oneOf","enum","format","indent","modifyOutputSchema","generatedTypes","modifyOutputSchemas","currentSchema","validate","AlignFeature","BlockquoteFeature","BlocksFeature","$createBlockNode","$isBlockNode","BlockNode","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","TestRecorderFeature","TreeViewFeature","BoldFeature","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","FixedToolbarFeature","InlineToolbarFeature","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","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","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\nimport type {\n  EditorConfig as LexicalEditorConfig,\n  SerializedEditorState,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport { withMergedProps } from '@payloadcms/ui/shared'\nimport { fileURLToPath } from 'node:url'\nimport path from 'path'\nimport {\n  afterChangeTraverseFields,\n  afterReadTraverseFields,\n  beforeChangeTraverseFields,\n  beforeValidateTraverseFields,\n  getDependencies,\n  withNullableJSONSchemaType,\n} from 'payload'\n\nimport type { FeatureProviderServer, ResolvedServerFeatureMap } from './features/types.js'\nimport type { SanitizedServerEditorConfig } from './lexical/config/types.js'\nimport type {\n  AdapterProps,\n  LexicalEditorProps,\n  LexicalRichTextAdapter,\n  LexicalRichTextAdapterProvider,\n} from './types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { RichTextCell, RichTextField } from './exports/client/index.js'\nimport { i18n } from './i18n.js'\nimport { defaultEditorConfig, defaultEditorFeatures } from './lexical/config/server/default.js'\nimport { loadFeatures } from './lexical/config/server/loader.js'\nimport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './lexical/config/server/sanitize.js'\nimport { cloneDeep } from './lexical/utils/cloneDeep.js'\nimport { populateLexicalPopulationPromises } from './populateGraphQL/populateLexicalPopulationPromises.js'\nimport { getGenerateComponentMap } from './utilities/generateComponentMap.js'\nimport { getGenerateSchemaMap } from './utilities/generateSchemaMap.js'\nimport { recurseNodeTree } from './utilities/recurseNodeTree.js'\nimport { richTextValidateHOC } from './validate/index.js'\n\nlet defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig = null\n\nconst filename = fileURLToPath(import.meta.url)\nconst dirname = path.dirname(filename)\n\nexport function lexicalEditor(props?: LexicalEditorProps): LexicalRichTextAdapterProvider {\n  return async ({ config, isRoot }) => {\n    if (process.env.NODE_ENV !== 'production') {\n      const resolvedDependencies = await getDependencies(dirname, [\n        'lexical',\n        '@lexical/headless',\n        '@lexical/link',\n        '@lexical/list',\n        '@lexical/mark',\n        '@lexical/markdown',\n        '@lexical/react',\n        '@lexical/rich-text',\n        '@lexical/selection',\n        '@lexical/utils',\n      ])\n\n      // Go through each resolved dependency. If any dependency has a mismatching version, throw an error\n      const foundVersions: {\n        [version: string]: string\n      } = {}\n      for (const [_pkg, { version }] of resolvedDependencies.resolved) {\n        if (!Object.keys(foundVersions).includes(version)) {\n          foundVersions[version] = _pkg\n        }\n      }\n      if (Object.keys(foundVersions).length !== 1) {\n        const formattedVersionsWithPackageNameString = Object.entries(foundVersions)\n          .map(([version, pkg]) => `${pkg}@${version}`)\n          .join(', ')\n\n        throw new Error(\n          `Mismatching lexical dependency versions found: ${formattedVersionsWithPackageNameString}. All lexical and @lexical/* packages must have the same version.`,\n        )\n      }\n    }\n\n    let features: FeatureProviderServer<unknown, unknown>[] = []\n    let resolvedFeatureMap: ResolvedServerFeatureMap\n\n    let finalSanitizedEditorConfig: SanitizedServerEditorConfig // For server only\n    if (!props || (!props.features && !props.lexical)) {\n      if (!defaultSanitizedServerEditorConfig) {\n        defaultSanitizedServerEditorConfig = await sanitizeServerEditorConfig(\n          defaultEditorConfig,\n          config,\n        )\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      finalSanitizedEditorConfig = cloneDeep(defaultSanitizedServerEditorConfig)\n\n      resolvedFeatureMap = finalSanitizedEditorConfig.resolvedFeatureMap\n    } else {\n      const rootEditor = config.editor\n      let rootEditorFeatures: FeatureProviderServer<unknown, unknown>[] = []\n      if (typeof rootEditor === 'object' && 'features' in rootEditor) {\n        rootEditorFeatures = (rootEditor as LexicalRichTextAdapter).features\n      }\n\n      features =\n        props.features && typeof props.features === 'function'\n          ? props.features({\n              defaultFeatures: cloneDeep(defaultEditorFeatures),\n              rootFeatures: rootEditorFeatures,\n            })\n          : (props.features as FeatureProviderServer<unknown, unknown>[])\n      if (!features) {\n        features = cloneDeep(defaultEditorFeatures)\n      }\n\n      const lexical: LexicalEditorConfig = props.lexical\n\n      resolvedFeatureMap = await loadFeatures({\n        config,\n        isRoot,\n        unSanitizedEditorConfig: {\n          features,\n          lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        },\n      })\n\n      finalSanitizedEditorConfig = {\n        features: sanitizeServerFeatures(resolvedFeatureMap),\n        lexical: lexical ? lexical : defaultEditorConfig.lexical,\n        resolvedFeatureMap,\n      }\n    }\n\n    const featureI18n = finalSanitizedEditorConfig.features.i18n\n    for (const lang in i18n) {\n      if (!featureI18n[lang]) {\n        featureI18n[lang] = {\n          lexical: {},\n        }\n      }\n\n      featureI18n[lang].lexical.general = i18n[lang]\n    }\n\n    return {\n      CellComponent: withMergedProps({\n        Component: RichTextCell,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      FieldComponent: withMergedProps({\n        Component: RichTextField,\n        toMergeIntoProps: {\n          admin: props?.admin,\n          lexicalEditorConfig: finalSanitizedEditorConfig.lexical,\n        },\n      }),\n      editorConfig: finalSanitizedEditorConfig,\n      features,\n      generateComponentMap: getGenerateComponentMap({\n        resolvedFeatureMap,\n      }),\n      generateSchemaMap: getGenerateSchemaMap({\n        resolvedFeatureMap,\n      }),\n      graphQLPopulationPromises({\n        context,\n        currentDepth,\n        depth,\n        draft,\n        field,\n        fieldPromises,\n        findMany,\n        flattenLocales,\n        overrideAccess,\n        populationPromises,\n        req,\n        showHiddenFields,\n        siblingDoc,\n      }) {\n        // check if there are any features with nodes which have populationPromises for this field\n        if (finalSanitizedEditorConfig?.features?.graphQLPopulationPromises?.size) {\n          populateLexicalPopulationPromises({\n            context,\n            currentDepth: currentDepth ?? 0,\n            depth,\n            draft,\n            editorPopulationPromises: finalSanitizedEditorConfig.features.graphQLPopulationPromises,\n            field,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            overrideAccess,\n            populationPromises,\n            req,\n            showHiddenFields,\n            siblingDoc,\n          })\n        }\n      },\n      hooks: {\n        afterChange: [\n          async ({\n            collection,\n            context: _context,\n            global,\n            operation,\n            path,\n            req,\n            schemaPath,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.afterChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n            const context: any = _context\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            /**\n             * Get the originalNodeIDMap from the beforeValidate hook, which is always run before this hook.\n             */\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = context?.internal?.richText?.[path.join('.')]?.originalNodeIDMap\n\n            if (!originalNodeIDMap || !Object.keys(originalNodeIDMap).length || !value) {\n              return value\n            }\n\n            recurseNodeTree({\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const afterChangeHooks = finalSanitizedEditorConfig.features.hooks.afterChange\n              if (afterChangeHooks?.has(node.type)) {\n                for (const hook of afterChangeHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(afterChange) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n\n                if (subFields?.length) {\n                  await afterChangeTraverseFields({\n                    collection,\n                    context,\n                    data: originalData,\n                    doc: data,\n                    fields: subFields,\n                    global,\n                    operation,\n                    path,\n                    previousDoc: data,\n                    previousSiblingDoc: { ...data },\n                    req,\n                    schemaPath,\n                    siblingData: originalData || {},\n                    siblingDoc: { ...data },\n                  })\n                }\n              }\n            }\n            return value\n          },\n        ],\n        afterRead: [\n          /**\n           * afterRead hooks do not receive the originalNode. Thus, they can run on all nodes, not just nodes with an ID.\n           */\n          async ({\n            collection,\n            context: context,\n            currentDepth,\n            depth,\n            draft,\n            fallbackLocale,\n            fieldPromises,\n            findMany,\n            flattenLocales,\n            global,\n            locale,\n            overrideAccess,\n            path,\n            populationPromises,\n            req,\n            schemaPath,\n            showHiddenFields,\n            triggerAccessControl,\n            triggerHooks,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.afterRead.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n            const flattenedNodes: SerializedLexicalNode[] = []\n\n            recurseNodeTree({\n              flattenedNodes,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            for (let node of flattenedNodes) {\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({\n                    context,\n                    currentDepth,\n                    depth,\n                    draft,\n                    fallbackLocale,\n                    fieldPromises,\n                    findMany,\n                    flattenLocales,\n                    locale,\n                    node,\n                    overrideAccess,\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    populationPromises,\n                    req,\n                    showHiddenFields,\n                    triggerAccessControl,\n                    triggerHooks,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n\n                if (subFields?.length) {\n                  afterReadTraverseFields({\n                    collection,\n                    context,\n                    currentDepth,\n                    depth,\n                    doc: data,\n                    draft,\n                    fallbackLocale,\n                    fieldPromises,\n                    fields: subFields,\n                    findMany,\n                    flattenLocales,\n                    global,\n                    locale,\n                    overrideAccess,\n                    path,\n                    populationPromises,\n                    req,\n                    schemaPath,\n                    showHiddenFields,\n                    siblingDoc: data,\n                    triggerAccessControl,\n                    triggerHooks,\n                  })\n                }\n              }\n            }\n\n            return value\n          },\n        ],\n        beforeChange: [\n          async ({\n            collection,\n            context: _context,\n            duplicate,\n            errors,\n            field,\n            global,\n            mergeLocaleActions,\n            operation,\n            path,\n            req,\n            schemaPath,\n            siblingData,\n            siblingDocWithLocales,\n            skipValidation,\n            value,\n          }) => {\n            if (\n              !finalSanitizedEditorConfig.features.hooks.beforeChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n\n            const context: any = _context\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            /**\n             * Get the originalNodeIDMap from the beforeValidate hook, which is always run before this hook.\n             */\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = context?.internal?.richText?.[path.join('.')]?.originalNodeIDMap\n\n            if (!originalNodeIDMap || !Object.keys(originalNodeIDMap).length || !value) {\n              return value\n            }\n\n            const originalNodeWithLocalesIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            recurseNodeTree({\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (siblingDocWithLocales?.[field.name]) {\n              recurseNodeTree({\n                nodeIDMap: originalNodeWithLocalesIDMap,\n                nodes:\n                  (siblingDocWithLocales[field.name] as SerializedEditorState)?.root?.children ??\n                  [],\n              })\n            }\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const beforeChangeHooks = finalSanitizedEditorConfig.features.hooks.beforeChange\n              if (beforeChangeHooks?.has(node.type)) {\n                for (const hook of beforeChangeHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(beforeChange) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    duplicate,\n                    errors,\n                    mergeLocaleActions,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    originalNodeWithLocales: originalNodeWithLocalesIDMap[id],\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                    skipValidation,\n                  })\n                }\n              }\n\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n                const originalDataWithLocales = subFieldDataFn({\n                  node: originalNodeWithLocalesIDMap[id],\n                  req,\n                })\n\n                if (subFields?.length) {\n                  await beforeChangeTraverseFields({\n                    id,\n                    collection,\n                    context,\n                    data,\n                    doc: originalData,\n                    docWithLocales: originalDataWithLocales ?? {},\n                    duplicate,\n                    errors,\n                    fields: subFields,\n                    global,\n                    mergeLocaleActions,\n                    operation,\n                    path,\n                    req,\n                    schemaPath,\n                    siblingData: data,\n                    siblingDoc: originalData,\n                    siblingDocWithLocales: originalDataWithLocales ?? {},\n                    skipValidation,\n                  })\n                }\n              }\n            }\n\n            /**\n             * within the beforeChange hook, id's may be re-generated.\n             * Example:\n             * 1. Seed data contains IDs for block feature blocks.\n             * 2. Those are used in beforeValidate\n             * 3. in beforeChange, those IDs are regenerated, because you cannot provide IDs during document creation. See baseIDField beforeChange hook for reasoning\n             * 4. Thus, in order for all post-beforeChange hooks to receive the correct ID, we need to update the originalNodeIDMap with the new ID's, by regenerating the nodeIDMap.\n             * The reason this is not generated for every hook, is to save on performance. We know we only really have to generate it in beforeValidate, which is the first hook,\n             * and in beforeChange, which is where modifications to the provided IDs can occur.\n             */\n            const newOriginalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            const previousValue = siblingData[field.name]\n\n            recurseNodeTree({\n              nodeIDMap: newOriginalNodeIDMap,\n              nodes: (previousValue as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (!context.internal) {\n              // Add to context, for other hooks to use\n              context.internal = {}\n            }\n            if (!context.internal.richText) {\n              context.internal.richText = {}\n            }\n            context.internal.richText[path.join('.')] = {\n              originalNodeIDMap: newOriginalNodeIDMap,\n            }\n\n            return value\n          },\n        ],\n        beforeValidate: [\n          async ({\n            collection,\n            context,\n            global,\n            operation,\n            overrideAccess,\n            path,\n            previousValue,\n            req,\n            schemaPath,\n            value,\n          }) => {\n            // return value if there are NO hooks\n            if (\n              !finalSanitizedEditorConfig.features.hooks.beforeValidate.size &&\n              !finalSanitizedEditorConfig.features.hooks.afterChange.size &&\n              !finalSanitizedEditorConfig.features.hooks.beforeChange.size &&\n              !finalSanitizedEditorConfig.features.getSubFields.size\n            ) {\n              return value\n            }\n\n            /**\n             * beforeValidate is the first field hook which runs. This is where we can create the node map, which can then be used in the other hooks.\n             *\n             */\n\n            /**\n             * flattenedNodes contains all nodes in the editor, in the order they appear in the editor. They will be used for the following hooks:\n             * - afterRead\n             *\n             * The other hooks require nodes to have IDs, which is why those are ran only from the nodeIDMap. They require IDs because they have both doc/siblingDoc and data/siblingData, and\n             * thus require a reliable way to match new node data to old node data. Given that node positions can change in between hooks, this is only reliably possible for nodes which are saved with\n             * an ID.\n             */\n            //const flattenedNodes: SerializedLexicalNode[] = []\n\n            /**\n             * Only nodes with id's (so, nodes with hooks added to them) will be added to the nodeIDMap. They will be used for the following hooks:\n             * - afterChange\n             * - beforeChange\n             * - beforeValidate\n             * - beforeDuplicate\n             *\n             * Other hooks are handled by the flattenedNodes. All nodes in the nodeIDMap are part of flattenedNodes.\n             */\n\n            const originalNodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n\n            recurseNodeTree({\n              nodeIDMap: originalNodeIDMap,\n              nodes: (previousValue as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            if (!context.internal) {\n              // Add to context, for other hooks to use\n              context.internal = {}\n            }\n            if (!(context as any).internal.richText) {\n              ;(context as any).internal.richText = {}\n            }\n            ;(context as any).internal.richText[path.join('.')] = {\n              originalNodeIDMap,\n            }\n\n            /**\n             * Now that the maps for all hooks are set up, we can run the validate hook\n             */\n            if (!finalSanitizedEditorConfig.features.hooks.beforeValidate.size) {\n              return value\n            }\n            const nodeIDMap: {\n              [key: string]: SerializedLexicalNode\n            } = {}\n            recurseNodeTree({\n              //flattenedNodes,\n              nodeIDMap,\n              nodes: (value as SerializedEditorState)?.root?.children ?? [],\n            })\n\n            // eslint-disable-next-line prefer-const\n            for (let [id, node] of Object.entries(nodeIDMap)) {\n              const beforeValidateHooks = finalSanitizedEditorConfig.features.hooks.beforeValidate\n              if (beforeValidateHooks?.has(node.type)) {\n                for (const hook of beforeValidateHooks.get(node.type)) {\n                  if (!originalNodeIDMap[id]) {\n                    console.warn(\n                      '(beforeValidate) No original node found for node with id',\n                      id,\n                      'node:',\n                      node,\n                      'path',\n                      path.join('.'),\n                    )\n                    continue\n                  }\n                  node = await hook({\n                    context,\n                    node,\n                    operation,\n                    originalNode: originalNodeIDMap[id],\n                    overrideAccess,\n                    parentRichTextFieldPath: path,\n                    parentRichTextFieldSchemaPath: schemaPath,\n                    req,\n                  })\n                }\n              }\n              const subFieldFn = finalSanitizedEditorConfig.features.getSubFields.get(node.type)\n              const subFieldDataFn = finalSanitizedEditorConfig.features.getSubFieldsData.get(\n                node.type,\n              )\n\n              if (subFieldFn) {\n                const subFields = subFieldFn({ node, req })\n                const data = subFieldDataFn({ node, req })\n                const originalData = subFieldDataFn({ node: originalNodeIDMap[id], req })\n\n                if (subFields?.length) {\n                  await beforeValidateTraverseFields({\n                    id,\n                    collection,\n                    context,\n                    data,\n                    doc: originalData,\n                    fields: subFields,\n                    global,\n                    operation,\n                    overrideAccess,\n                    path,\n                    req,\n                    schemaPath,\n                    siblingData: data,\n                    siblingDoc: originalData,\n                  })\n                }\n              }\n            }\n\n            return value\n          },\n        ],\n      },\n      i18n: featureI18n,\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      validate: richTextValidateHOC({\n        editorConfig: finalSanitizedEditorConfig,\n      }),\n    }\n  }\n}\n\nexport { AlignFeature } from './features/align/feature.server.js'\nexport { BlockquoteFeature } from './features/blockquote/feature.server.js'\nexport { BlocksFeature, type BlocksFeatureProps } from './features/blocks/feature.server.js'\nexport {\n  $createBlockNode,\n  $isBlockNode,\n  type BlockFields,\n  BlockNode,\n  type SerializedBlockNode,\n} from './features/blocks/nodes/BlocksNode.js'\n\nexport { LinebreakHTMLConverter } from './features/converters/html/converter/converters/linebreak.js'\nexport { ParagraphHTMLConverter } from './features/converters/html/converter/converters/paragraph.js'\nexport { TextHTMLConverter } from './features/converters/html/converter/converters/text.js'\n\nexport { defaultHTMLConverters } from './features/converters/html/converter/defaultConverters.js'\nexport {\n  convertLexicalNodesToHTML,\n  convertLexicalToHTML,\n} from './features/converters/html/converter/index.js'\nexport type { HTMLConverter } from './features/converters/html/converter/types.js'\nexport {\n  HTMLConverterFeature,\n  type HTMLConverterFeatureProps,\n} from './features/converters/html/feature.server.js'\nexport { consolidateHTMLConverters, lexicalHTML } from './features/converters/html/field/index.js'\nexport { TestRecorderFeature } from './features/debug/testRecorder/feature.server.js'\nexport { TreeViewFeature } from './features/debug/treeView/feature.server.js'\nexport { BoldFeature } from './features/format/bold/feature.server.js'\nexport { InlineCodeFeature } from './features/format/inlineCode/feature.server.js'\n\nexport { ItalicFeature } from './features/format/italic/feature.server.js'\nexport { StrikethroughFeature } from './features/format/strikethrough/feature.server.js'\nexport { SubscriptFeature } from './features/format/subscript/feature.server.js'\nexport { SuperscriptFeature } from './features/format/superscript/feature.server.js'\nexport { UnderlineFeature } from './features/format/underline/feature.server.js'\nexport { HeadingFeature, type HeadingFeatureProps } from './features/heading/feature.server.js'\nexport { HorizontalRuleFeature } from './features/horizontalRule/feature.server.js'\n\nexport { IndentFeature } from './features/indent/feature.server.js'\nexport { LinkFeature, type LinkFeatureServerProps } from './features/link/feature.server.js'\n\nexport {\n  $createAutoLinkNode,\n  $isAutoLinkNode,\n  AutoLinkNode,\n} from './features/link/nodes/AutoLinkNode.js'\nexport {\n  $createLinkNode,\n  $isLinkNode,\n  LinkNode,\n  TOGGLE_LINK_COMMAND,\n} from './features/link/nodes/LinkNode.js'\nexport type {\n  LinkFields,\n  SerializedAutoLinkNode,\n  SerializedLinkNode,\n} from './features/link/nodes/types.js'\nexport { ChecklistFeature } from './features/lists/checklist/feature.server.js'\nexport { OrderedListFeature } from './features/lists/orderedList/feature.server.js'\nexport { UnorderedListFeature } from './features/lists/unorderedList/feature.server.js'\nexport { LexicalPluginToLexicalFeature } from './features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from './features/migrations/slateToLexical/converter/converters/blockquote/index.js'\nexport { SlateHeadingConverter } from './features/migrations/slateToLexical/converter/converters/heading/index.js'\nexport { SlateIndentConverter } from './features/migrations/slateToLexical/converter/converters/indent/index.js'\nexport { SlateLinkConverter } from './features/migrations/slateToLexical/converter/converters/link/index.js'\nexport { SlateListItemConverter } from './features/migrations/slateToLexical/converter/converters/listItem/index.js'\nexport { SlateOrderedListConverter } from './features/migrations/slateToLexical/converter/converters/orderedList/index.js'\nexport { SlateRelationshipConverter } from './features/migrations/slateToLexical/converter/converters/relationship/index.js'\nexport { SlateUnknownConverter } from './features/migrations/slateToLexical/converter/converters/unknown/index.js'\nexport { SlateUnorderedListConverter } from './features/migrations/slateToLexical/converter/converters/unorderedList/index.js'\nexport { SlateUploadConverter } from './features/migrations/slateToLexical/converter/converters/upload/index.js'\nexport { defaultSlateConverters } from './features/migrations/slateToLexical/converter/defaultConverters.js'\n\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from './features/migrations/slateToLexical/converter/index.js'\nexport type {\n  SlateNode,\n  SlateNodeConverter,\n} from './features/migrations/slateToLexical/converter/types.js'\nexport { SlateToLexicalFeature } from './features/migrations/slateToLexical/feature.server.js'\n\nexport { ParagraphFeature } from './features/paragraph/feature.server.js'\nexport {\n  RelationshipFeature,\n  type RelationshipFeatureProps,\n} from './features/relationship/feature.server.js'\nexport {\n  $createRelationshipNode,\n  $isRelationshipNode,\n  type RelationshipData,\n  RelationshipNode,\n  type SerializedRelationshipNode,\n} from './features/relationship/nodes/RelationshipNode.js'\n\nexport { FixedToolbarFeature } from './features/toolbars/fixed/feature.server.js'\nexport { InlineToolbarFeature } from './features/toolbars/inline/feature.server.js'\n\nexport type { ToolbarGroup, ToolbarGroupItem } from './features/toolbars/types.js'\nexport { createNode } from './features/typeUtilities.js'\nexport type {\n  AfterChangeNodeHook,\n  AfterChangeNodeHookArgs,\n  AfterReadNodeHook,\n  AfterReadNodeHookArgs,\n  BaseNodeHookArgs,\n  BeforeChangeNodeHook,\n  BeforeChangeNodeHookArgs,\n  BeforeValidateNodeHook,\n  BeforeValidateNodeHookArgs,\n  ClientComponentProps,\n  ClientFeature,\n  ClientFeatureProviderMap,\n  FeatureProviderClient,\n  FeatureProviderProviderClient,\n  FeatureProviderProviderServer,\n  FeatureProviderServer,\n  NodeValidation,\n  NodeWithHooks,\n  PluginComponent,\n  PluginComponentWithAnchor,\n  PopulationPromise,\n  ResolvedClientFeature,\n  ResolvedClientFeatureMap,\n  ResolvedServerFeature,\n  ResolvedServerFeatureMap,\n  SanitizedClientFeatures,\n  SanitizedPlugin,\n  SanitizedServerFeatures,\n  ServerFeature,\n  ServerFeatureProviderMap,\n} from './features/types.js'\n\nexport { UploadFeature } from './features/upload/feature.server.js'\n\nexport type { UploadFeatureProps } from './features/upload/feature.server.js'\nexport {\n  $createUploadNode,\n  $isUploadNode,\n  type SerializedUploadNode,\n  type UploadData,\n  UploadNode,\n} from './features/upload/nodes/UploadNode.js'\n\nexport {\n  defaultEditorConfig,\n  defaultEditorFeatures,\n  defaultEditorLexicalConfig,\n} from './lexical/config/server/default.js'\nexport { loadFeatures, sortFeaturesForOptimalLoading } from './lexical/config/server/loader.js'\n\nexport {\n  sanitizeServerEditorConfig,\n  sanitizeServerFeatures,\n} from './lexical/config/server/sanitize.js'\nexport type {\n  ClientEditorConfig,\n  SanitizedClientEditorConfig,\n  SanitizedServerEditorConfig,\n  ServerEditorConfig,\n} from './lexical/config/types.js'\n\nexport { getEnabledNodes } from './lexical/nodes/index.js'\nexport { ENABLE_SLASH_MENU_COMMAND } from './lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.js'\nexport type { AdapterProps }\n\nexport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from './lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\n\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 './lexical/utils/nodeFormat.js'\n\nexport { sanitizeUrl, validateUrl } from './lexical/utils/url.js'\nexport { defaultRichTextValue } from './populateGraphQL/defaultValue.js'\n\nexport type { LexicalEditorProps, LexicalRichTextAdapter } from './types.js'\n"],"names":["withMergedProps","fileURLToPath","path","afterChangeTraverseFields","afterReadTraverseFields","beforeChangeTraverseFields","beforeValidateTraverseFields","getDependencies","withNullableJSONSchemaType","RichTextCell","RichTextField","i18n","defaultEditorConfig","defaultEditorFeatures","loadFeatures","sanitizeServerEditorConfig","sanitizeServerFeatures","cloneDeep","populateLexicalPopulationPromises","getGenerateComponentMap","getGenerateSchemaMap","recurseNodeTree","richTextValidateHOC","defaultSanitizedServerEditorConfig","filename","url","dirname","lexicalEditor","props","config","isRoot","process","env","NODE_ENV","resolvedDependencies","foundVersions","_pkg","version","resolved","Object","keys","includes","length","formattedVersionsWithPackageNameString","entries","map","pkg","join","Error","features","resolvedFeatureMap","finalSanitizedEditorConfig","lexical","rootEditor","editor","rootEditorFeatures","defaultFeatures","rootFeatures","unSanitizedEditorConfig","featureI18n","lang","general","CellComponent","Component","toMergeIntoProps","admin","lexicalEditorConfig","FieldComponent","editorConfig","generateComponentMap","generateSchemaMap","graphQLPopulationPromises","context","currentDepth","depth","draft","field","fieldPromises","findMany","flattenLocales","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","size","editorPopulationPromises","hooks","afterChange","collection","_context","global","operation","schemaPath","value","getSubFields","nodeIDMap","originalNodeIDMap","internal","richText","nodes","root","children","id","node","afterChangeHooks","has","type","hook","get","console","warn","originalNode","parentRichTextFieldPath","parentRichTextFieldSchemaPath","subFieldFn","subFieldDataFn","getSubFieldsData","subFields","data","originalData","doc","fields","previousDoc","previousSiblingDoc","siblingData","afterRead","fallbackLocale","locale","triggerAccessControl","triggerHooks","flattenedNodes","afterReadHooks","beforeChange","duplicate","errors","mergeLocaleActions","siblingDocWithLocales","skipValidation","originalNodeWithLocalesIDMap","name","beforeChangeHooks","originalNodeWithLocales","originalDataWithLocales","docWithLocales","newOriginalNodeIDMap","previousValue","beforeValidate","beforeValidateHooks","outputSchema","collectionIDFieldTypes","interfaceNameDefinitions","isRequired","properties","additionalProperties","items","required","direction","oneOf","enum","format","indent","modifyOutputSchema","generatedTypes","modifyOutputSchemas","currentSchema","validate","AlignFeature","BlockquoteFeature","BlocksFeature","$createBlockNode","$isBlockNode","BlockNode","LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters","convertLexicalNodesToHTML","convertLexicalToHTML","HTMLConverterFeature","consolidateHTMLConverters","lexicalHTML","TestRecorderFeature","TreeViewFeature","BoldFeature","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","FixedToolbarFeature","InlineToolbarFeature","createNode","UploadFeature","$createUploadNode","$isUploadNode","UploadNode","defaultEditorLexicalConfig","sortFeaturesForOptimalLoading","getEnabledNodes","ENABLE_SLASH_MENU_COMMAND","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","sanitizeUrl","validateUrl","defaultRichTextValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lexical/EditorPlugin.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { SanitizedPlugin } from '../features/types.js';
+export declare const EditorPlugin: React.FC<{
+    anchorElem?: HTMLDivElement;
+    clientProps: unknown;
+    plugin: SanitizedPlugin;
+}>;
+//# sourceMappingURL=EditorPlugin.d.ts.map

package/dist/lexical/EditorPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../src/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,WAAW,EAAE,OAAO,CAAA;IACpB,MAAM,EAAE,eAAe,CAAA;CACxB,CAQA,CAAA"}

package/dist/lexical/EditorPlugin.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+export const EditorPlugin = ({ anchorElem, clientProps, plugin })=>{
+    if (plugin.position === 'floatingAnchorElem') {
+        return plugin.Component && /*#__PURE__*/ _jsx(plugin.Component, {
+            anchorElem: anchorElem,
+            clientProps: clientProps
+        });
+    }
+    return plugin.Component && /*#__PURE__*/ _jsx(plugin.Component, {
+        clientProps: clientProps
+    });
+};
+
+//# sourceMappingURL=EditorPlugin.js.map

package/dist/lexical/EditorPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lexical/EditorPlugin.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { SanitizedPlugin } from '../features/types.js'\n\nexport const EditorPlugin: React.FC<{\n  anchorElem?: HTMLDivElement\n  clientProps: unknown\n  plugin: SanitizedPlugin\n}> = ({ anchorElem, clientProps, plugin }) => {\n  if (plugin.position === 'floatingAnchorElem') {\n    return (\n      plugin.Component && <plugin.Component anchorElem={anchorElem} clientProps={clientProps} />\n    )\n  }\n\n  return plugin.Component && <plugin.Component clientProps={clientProps} />\n}\n"],"names":["React","EditorPlugin","anchorElem","clientProps","plugin","position","Component"],"rangeMappings":";;;;;;;;;;;;","mappings":";AAAA,OAAOA,WAAW,QAAO;AAIzB,OAAO,MAAMC,eAIR,CAAC,EAAEC,UAAU,EAAEC,WAAW,EAAEC,MAAM,EAAE;IACvC,IAAIA,OAAOC,QAAQ,KAAK,sBAAsB;QAC5C,OACED,OAAOE,SAAS,kBAAI,KAACF,OAAOE,SAAS;YAACJ,YAAYA;YAAYC,aAAaA;;IAE/E;IAEA,OAAOC,OAAOE,SAAS,kBAAI,KAACF,OAAOE,SAAS;QAACH,aAAaA;;AAC5D,EAAC"}

package/dist/lexical/LexicalEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalEditor.d.ts","sourceRoot":"","sources":["../../src/lexical/LexicalEditor.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAGhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAClC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,GAAG;IACxD,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;CACpD,CA4KF,CAAA"}

package/dist/lexical/LexicalEditor.js

@@ -0,0 +1,192 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary.js';
+import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin.js';
+import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin.js';
+import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin.js';
+import { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin.js';
+import { useTranslation } from '@payloadcms/ui';
+import { BLUR_COMMAND, COMMAND_PRIORITY_LOW, FOCUS_COMMAND } from 'lexical';
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { EditorPlugin } from './EditorPlugin.js';
+import { useEditorConfigContext } from './config/client/EditorConfigProvider.js';
+import { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js';
+import { SlashMenuPlugin } from './plugins/SlashMenu/index.js';
+import { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js';
+import { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js';
+import { LexicalContentEditable } from './ui/ContentEditable.js';
+export const LexicalEditor = (props)=>{
+    const { editorConfig, editorContainerRef, onChange } = props;
+    const editorConfigContext = useEditorConfigContext();
+    const [editor] = useLexicalComposerContext();
+    const { t } = useTranslation();
+    const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
+    const onRef = (_floatingAnchorElem)=>{
+        if (_floatingAnchorElem !== null) {
+            setFloatingAnchorElem(_floatingAnchorElem);
+        }
+    };
+    useEffect(()=>{
+        if (!editorConfigContext?.uuid) {
+            console.error('Lexical Editor must be used within an EditorConfigProvider');
+            return;
+        }
+        if (editorConfigContext?.parentEditor?.uuid) {
+            editorConfigContext.parentEditor?.registerChild(editorConfigContext.uuid, editorConfigContext);
+        }
+        const handleFocus = ()=>{
+            editorConfigContext.focusEditor(editorConfigContext);
+        };
+        const handleBlur = ()=>{
+            editorConfigContext.blurEditor(editorConfigContext);
+        };
+        const unregisterFocus = editor.registerCommand(FOCUS_COMMAND, ()=>{
+            handleFocus();
+            return true;
+        }, COMMAND_PRIORITY_LOW);
+        const unregisterBlur = editor.registerCommand(BLUR_COMMAND, ()=>{
+            handleBlur();
+            return true;
+        }, COMMAND_PRIORITY_LOW);
+        return ()=>{
+            unregisterFocus();
+            unregisterBlur();
+            editorConfigContext.parentEditor?.unregisterChild?.(editorConfigContext.uuid);
+        };
+    }, [
+        editor,
+        editorConfigContext
+    ]);
+    const [isSmallWidthViewport, setIsSmallWidthViewport] = useState(false);
+    useEffect(()=>{
+        const updateViewPortWidth = ()=>{
+            const isNextSmallWidthViewport = window.matchMedia('(max-width: 768px)').matches;
+            if (isNextSmallWidthViewport !== isSmallWidthViewport) {
+                setIsSmallWidthViewport(isNextSmallWidthViewport);
+            }
+        };
+        updateViewPortWidth();
+        window.addEventListener('resize', updateViewPortWidth);
+        return ()=>{
+            window.removeEventListener('resize', updateViewPortWidth);
+        };
+    }, [
+        isSmallWidthViewport
+    ]);
+    return /*#__PURE__*/ _jsxs(React.Fragment, {
+        children: [
+            editorConfig.features.plugins.map((plugin)=>{
+                if (plugin.position === 'aboveContainer') {
+                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                        clientProps: plugin.clientProps,
+                        plugin: plugin
+                    }, plugin.key);
+                }
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "editor-container",
+                ref: editorContainerRef,
+                children: [
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'top') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(RichTextPlugin, {
+                        ErrorBoundary: LexicalErrorBoundary,
+                        contentEditable: /*#__PURE__*/ _jsx("div", {
+                            className: "editor-scroller",
+                            children: /*#__PURE__*/ _jsx("div", {
+                                className: "editor",
+                                ref: onRef,
+                                children: /*#__PURE__*/ _jsx(LexicalContentEditable, {})
+                            })
+                        }),
+                        placeholder: /*#__PURE__*/ _jsx("p", {
+                            className: "editor-placeholder",
+                            children: t('lexical:general:placeholder')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx(OnChangePlugin, {
+                        // Selection changes can be ignored here, reducing the
+                        // frequency that the FieldComponent and Payload receive updates.
+                        // Selection changes are only needed if you are saving selection state
+                        ignoreSelectionChange: true,
+                        onChange: (editorState, editor, tags)=>{
+                            // Ignore any onChange event triggered by focus only
+                            if (!tags.has('focus') || tags.size > 1) {
+                                if (onChange != null) onChange(editorState, editor, tags);
+                            }
+                        }
+                    }),
+                    floatingAnchorElem && /*#__PURE__*/ _jsxs(React.Fragment, {
+                        children: [
+                            !isSmallWidthViewport && editor.isEditable() && /*#__PURE__*/ _jsxs(React.Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(DraggableBlockPlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    }),
+                                    /*#__PURE__*/ _jsx(AddBlockHandlePlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    })
+                                ]
+                            }),
+                            editorConfig.features.plugins.map((plugin)=>{
+                                if (plugin.position === 'floatingAnchorElem' && !(plugin.desktopOnly === true && isSmallWidthViewport)) {
+                                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                        anchorElem: floatingAnchorElem,
+                                        clientProps: plugin.clientProps,
+                                        plugin: plugin
+                                    }, plugin.key);
+                                }
+                            }),
+                            editor.isEditable() && /*#__PURE__*/ _jsx(React.Fragment, {
+                                children: /*#__PURE__*/ _jsx(SlashMenuPlugin, {
+                                    anchorElem: floatingAnchorElem
+                                })
+                            })
+                        ]
+                    }),
+                    editor.isEditable() && /*#__PURE__*/ _jsxs(React.Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(HistoryPlugin, {}),
+                            editorConfig?.features?.markdownTransformers?.length > 0 && /*#__PURE__*/ _jsx(MarkdownShortcutPlugin, {})
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TabIndentationPlugin, {}),
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'normal') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    }),
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'bottom') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    })
+                ]
+            }),
+            editorConfig.features.plugins.map((plugin)=>{
+                if (plugin.position === 'belowContainer') {
+                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                        clientProps: plugin.clientProps,
+                        plugin: plugin
+                    }, plugin.key);
+                }
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=LexicalEditor.js.map

package/dist/lexical/LexicalEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary.js'\nimport { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin.js'\nimport { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin.js'\nimport { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin.js'\nimport { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin.js'\nimport { useTranslation } from '@payloadcms/ui'\nimport { BLUR_COMMAND, COMMAND_PRIORITY_LOW, FOCUS_COMMAND } from 'lexical'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider.js'\n\nimport { EditorPlugin } from './EditorPlugin.js'\nimport './LexicalEditor.scss'\nimport { useEditorConfigContext } from './config/client/EditorConfigProvider.js'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js'\nimport { SlashMenuPlugin } from './plugins/SlashMenu/index.js'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js'\nimport { LexicalContentEditable } from './ui/ContentEditable.js'\n\nexport const LexicalEditor: React.FC<\n  Pick<LexicalProviderProps, 'editorConfig' | 'onChange'> & {\n    editorContainerRef: React.RefObject<HTMLDivElement>\n  }\n> = (props) => {\n  const { editorConfig, editorContainerRef, onChange } = props\n  const editorConfigContext = useEditorConfigContext()\n  const [editor] = useLexicalComposerContext()\n  const { t } = useTranslation<{}, string>()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  useEffect(() => {\n    if (!editorConfigContext?.uuid) {\n      console.error('Lexical Editor must be used within an EditorConfigProvider')\n      return\n    }\n    if (editorConfigContext?.parentEditor?.uuid) {\n      editorConfigContext.parentEditor?.registerChild(editorConfigContext.uuid, editorConfigContext)\n    }\n\n    const handleFocus = () => {\n      editorConfigContext.focusEditor(editorConfigContext)\n    }\n\n    const handleBlur = () => {\n      editorConfigContext.blurEditor(editorConfigContext)\n    }\n\n    const unregisterFocus = editor.registerCommand<MouseEvent>(\n      FOCUS_COMMAND,\n      () => {\n        handleFocus()\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n\n    const unregisterBlur = editor.registerCommand<MouseEvent>(\n      BLUR_COMMAND,\n      () => {\n        handleBlur()\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n\n    return () => {\n      unregisterFocus()\n      unregisterBlur()\n      editorConfigContext.parentEditor?.unregisterChild?.(editorConfigContext.uuid)\n    }\n  }, [editor, editorConfigContext])\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 768px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'aboveContainer') {\n          return <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <div className=\"editor-container\" ref={editorContainerRef}>\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'top') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n        <RichTextPlugin\n          ErrorBoundary={LexicalErrorBoundary}\n          contentEditable={\n            <div className=\"editor-scroller\">\n              <div className=\"editor\" ref={onRef}>\n                <LexicalContentEditable />\n              </div>\n            </div>\n          }\n          placeholder={<p className=\"editor-placeholder\">{t('lexical:general:placeholder')}</p>}\n        />\n        <OnChangePlugin\n          // Selection changes can be ignored here, reducing the\n          // frequency that the FieldComponent and Payload receive updates.\n          // Selection changes are only needed if you are saving selection state\n          ignoreSelectionChange\n          onChange={(editorState, editor, tags) => {\n            // Ignore any onChange event triggered by focus only\n            if (!tags.has('focus') || tags.size > 1) {\n              if (onChange != null) onChange(editorState, editor, tags)\n            }\n          }}\n        />\n        {floatingAnchorElem && (\n          <React.Fragment>\n            {!isSmallWidthViewport && editor.isEditable() && (\n              <React.Fragment>\n                <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n                <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n              </React.Fragment>\n            )}\n            {editorConfig.features.plugins.map((plugin) => {\n              if (\n                plugin.position === 'floatingAnchorElem' &&\n                !(plugin.desktopOnly === true && isSmallWidthViewport)\n              ) {\n                return (\n                  <EditorPlugin\n                    anchorElem={floatingAnchorElem}\n                    clientProps={plugin.clientProps}\n                    key={plugin.key}\n                    plugin={plugin}\n                  />\n                )\n              }\n            })}\n            {editor.isEditable() && (\n              <React.Fragment>\n                <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n              </React.Fragment>\n            )}\n          </React.Fragment>\n        )}\n        {editor.isEditable() && (\n          <React.Fragment>\n            <HistoryPlugin />\n            {editorConfig?.features?.markdownTransformers?.length > 0 && <MarkdownShortcutPlugin />}\n          </React.Fragment>\n        )}\n\n        <TabIndentationPlugin />\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'normal') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'bottom') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n      </div>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'belowContainer') {\n          return <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["useLexicalComposerContext","LexicalErrorBoundary","HistoryPlugin","OnChangePlugin","RichTextPlugin","TabIndentationPlugin","useTranslation","BLUR_COMMAND","COMMAND_PRIORITY_LOW","FOCUS_COMMAND","React","useEffect","useState","EditorPlugin","useEditorConfigContext","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","editorContainerRef","onChange","editorConfigContext","editor","t","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","uuid","console","error","parentEditor","registerChild","handleFocus","focusEditor","handleBlur","blurEditor","unregisterFocus","registerCommand","unregisterBlur","unregisterChild","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","Fragment","features","plugins","map","plugin","position","clientProps","key","div","className","ref","ErrorBoundary","contentEditable","placeholder","p","ignoreSelectionChange","editorState","tags","has","size","isEditable","anchorElem","desktopOnly","markdownTransformers","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lexical/LexicalProvider.d.ts

@@ -0,0 +1,18 @@
+import type { FormFieldBase } from '@payloadcms/ui';
+import type { EditorState, LexicalEditor, SerializedEditorState } from 'lexical';
+import * as React from 'react';
+import type { SanitizedClientEditorConfig } from './config/types.js';
+export type LexicalProviderProps = {
+    editorConfig: SanitizedClientEditorConfig;
+    fieldProps: FormFieldBase & {
+        editorConfig: SanitizedClientEditorConfig;
+        name: string;
+        richTextComponentMap: Map<string, React.ReactNode>;
+    };
+    onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void;
+    path: string;
+    readOnly: boolean;
+    value: SerializedEditorState;
+};
+export declare const LexicalProvider: React.FC<LexicalProviderProps>;
+//# sourceMappingURL=LexicalProvider.d.ts.map

package/dist/lexical/LexicalProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../src/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGhF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AASpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAsE1D,CAAA"}

package/dist/lexical/LexicalProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lexical/LexicalProvider.tsx"],"sourcesContent":["'use client'\nimport type { InitialConfigType } from '@lexical/react/LexicalComposer.js'\nimport type { FormFieldBase } from '@payloadcms/ui'\nimport type { EditorState, LexicalEditor, SerializedEditorState } from 'lexical'\n\nimport { LexicalComposer } from '@lexical/react/LexicalComposer.js'\nimport * as React from 'react'\nimport { useMemo } from 'react'\n\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js'\nimport {\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './config/client/EditorConfigProvider.js'\nimport { getEnabledNodes } from './nodes/index.js'\n\nexport type LexicalProviderProps = {\n  editorConfig: SanitizedClientEditorConfig\n  fieldProps: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void\n  path: string\n  readOnly: boolean\n  value: SerializedEditorState\n}\nexport const LexicalProvider: React.FC<LexicalProviderProps> = (props) => {\n  const { editorConfig, fieldProps, onChange, path, readOnly, value } = props\n\n  const parentContext = useEditorConfigContext()\n\n  const editorContainerRef = React.useRef<HTMLDivElement>(null)\n\n  const processedValue = useMemo(() => {\n    let processed = value\n    if (editorConfig?.features?.hooks?.load?.length) {\n      editorConfig.features.hooks.load.forEach((hook) => {\n        processed = hook({ incomingEditorState: processed })\n      })\n    }\n    return processed\n  }, [editorConfig, value])\n\n  // useMemo for the initialConfig that depends on readOnly and processedValue\n  const initialConfig = useMemo<InitialConfigType>(() => {\n    if (processedValue && typeof processedValue !== 'object') {\n      throw new Error(\n        'The value passed to the Lexical editor is not an object. This is not supported. Please remove the data from the field and start again. This is the value that was passed in: ' +\n          JSON.stringify(processedValue),\n      )\n    }\n\n    if (processedValue && Array.isArray(processedValue) && !('root' in processedValue)) {\n      throw new Error(\n        'You have tried to pass in data from the old, Slate editor, to the new, Lexical editor. This is not supported. There is no automatic conversion from Slate to Lexical data available yet (coming soon). Please remove the data from the field and start again.',\n      )\n    }\n\n    if (processedValue && 'jsonContent' in processedValue) {\n      throw new Error(\n        'You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.',\n      )\n    }\n\n    return {\n      editable: readOnly !== true,\n      editorState: processedValue != null ? JSON.stringify(processedValue) : undefined,\n      namespace: editorConfig.lexical.namespace,\n      nodes: [...getEnabledNodes({ editorConfig })],\n      onError: (error: Error) => {\n        throw error\n      },\n      theme: editorConfig.lexical.theme,\n    }\n  }, [editorConfig, processedValue, readOnly])\n\n  if (!initialConfig) {\n    return <p>Loading...</p>\n  }\n\n  return (\n    <LexicalComposer initialConfig={initialConfig} key={path}>\n      <EditorConfigProvider\n        editorConfig={editorConfig}\n        editorContainerRef={editorContainerRef}\n        fieldProps={fieldProps}\n        parentContext={parentContext}\n      >\n        <LexicalEditorComponent\n          editorConfig={editorConfig}\n          editorContainerRef={editorContainerRef}\n          onChange={onChange}\n        />\n      </EditorConfigProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["LexicalComposer","React","useMemo","LexicalEditor","LexicalEditorComponent","EditorConfigProvider","useEditorConfigContext","getEnabledNodes","LexicalProvider","props","editorConfig","fieldProps","onChange","path","readOnly","value","parentContext","editorContainerRef","useRef","processedValue","processed","features","hooks","load","length","forEach","hook","incomingEditorState","initialConfig","Error","JSON","stringify","Array","isArray","editable","editorState","undefined","namespace","lexical","nodes","onError","error","theme","p"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAKA,SAASA,eAAe,QAAQ,oCAAmC;AACnE,YAAYC,WAAW,QAAO;AAC9B,SAASC,OAAO,QAAQ,QAAO;AAI/B,SAASC,iBAAiBC,sBAAsB,QAAQ,qBAAoB;AAC5E,SACEC,oBAAoB,EACpBC,sBAAsB,QACjB,0CAAyC;AAChD,SAASC,eAAe,QAAQ,mBAAkB;AAclD,OAAO,MAAMC,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGN;IAEtE,MAAMO,gBAAgBV;IAEtB,MAAMW,qBAAqBhB,MAAMiB,MAAM,CAAiB;IAExD,MAAMC,iBAAiBjB,QAAQ;QAC7B,IAAIkB,YAAYL;QAChB,IAAIL,cAAcW,UAAUC,OAAOC,MAAMC,QAAQ;YAC/Cd,aAAaW,QAAQ,CAACC,KAAK,CAACC,IAAI,CAACE,OAAO,CAAC,CAACC;gBACxCN,YAAYM,KAAK;oBAAEC,qBAAqBP;gBAAU;YACpD;QACF;QACA,OAAOA;IACT,GAAG;QAACV;QAAcK;KAAM;IAExB,4EAA4E;IAC5E,MAAMa,gBAAgB1B,QAA2B;QAC/C,IAAIiB,kBAAkB,OAAOA,mBAAmB,UAAU;YACxD,MAAM,IAAIU,MACR,kLACEC,KAAKC,SAAS,CAACZ;QAErB;QAEA,IAAIA,kBAAkBa,MAAMC,OAAO,CAACd,mBAAmB,CAAE,CAAA,UAAUA,cAAa,GAAI;YAClF,MAAM,IAAIU,MACR;QAEJ;QAEA,IAAIV,kBAAkB,iBAAiBA,gBAAgB;YACrD,MAAM,IAAIU,MACR;QAEJ;QAEA,OAAO;YACLK,UAAUpB,aAAa;YACvBqB,aAAahB,kBAAkB,OAAOW,KAAKC,SAAS,CAACZ,kBAAkBiB;YACvEC,WAAW3B,aAAa4B,OAAO,CAACD,SAAS;YACzCE,OAAO;mBAAIhC,gBAAgB;oBAAEG;gBAAa;aAAG;YAC7C8B,SAAS,CAACC;gBACR,MAAMA;YACR;YACAC,OAAOhC,aAAa4B,OAAO,CAACI,KAAK;QACnC;IACF,GAAG;QAAChC;QAAcS;QAAgBL;KAAS;IAE3C,IAAI,CAACc,eAAe;QAClB,qBAAO,KAACe;sBAAE;;IACZ;IAEA,qBACE,KAAC3C;QAAgB4B,eAAeA;kBAC9B,cAAA,KAACvB;YACCK,cAAcA;YACdO,oBAAoBA;YACpBN,YAAYA;YACZK,eAAeA;sBAEf,cAAA,KAACZ;gBACCM,cAAcA;gBACdO,oBAAoBA;gBACpBL,UAAUA;;;OAVoCC;AAexD,EAAC"}