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

package/dist/features/toolbars/shared/ToolbarDropdown/index.js

@@ -0,0 +1,141 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useCallback, useEffect } from 'react';
+const baseClass = 'toolbar-popup__dropdown';
+import { mergeRegister } from '@lexical/utils';
+import { useTranslation } from '@payloadcms/ui';
+import { $getSelection } from 'lexical';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
+import { DropDown, DropDownItem } from './DropDown.js';
+const ToolbarItem = ({ active, anchorElem, editor, enabled, item })=>{
+    const { i18n } = useTranslation();
+    if (item.Component) {
+        return item?.Component && /*#__PURE__*/ _jsx(item.Component, {
+            active: active,
+            anchorElem: anchorElem,
+            editor: editor,
+            enabled: enabled,
+            item: item
+        }, item.key);
+    }
+    let title = item.key;
+    if (item.label) {
+        title = typeof item.label === 'function' ? item.label({
+            i18n
+        }) : item.label;
+    }
+    // Crop title to max. 25 characters
+    if (title.length > 25) {
+        title = title.substring(0, 25) + '...';
+    }
+    return /*#__PURE__*/ _jsxs(DropDownItem, {
+        active: active,
+        editor: editor,
+        enabled: enabled,
+        item: item,
+        children: [
+            item?.ChildComponent && /*#__PURE__*/ _jsx(item.ChildComponent, {}),
+            /*#__PURE__*/ _jsx("span", {
+                className: "text",
+                children: title
+            })
+        ]
+    }, item.key);
+};
+export const ToolbarDropdown = ({ Icon, anchorElem, classNames, editor, groupKey, items, itemsContainerClassNames, label, maxActiveItems, onActiveChange })=>{
+    const [activeItemKeys, setActiveItemKeys] = React.useState([]);
+    const [enabledItemKeys, setEnabledItemKeys] = React.useState([]);
+    const editorConfigContext = useEditorConfigContext();
+    const updateStates = useCallback(()=>{
+        editor.getEditorState().read(()=>{
+            const selection = $getSelection();
+            const _activeItemKeys = [];
+            const _activeItems = [];
+            const _enabledItemKeys = [];
+            for (const item of items){
+                if (item.isActive && (!maxActiveItems || _activeItemKeys.length < maxActiveItems)) {
+                    const isActive = item.isActive({
+                        editor,
+                        editorConfigContext,
+                        selection
+                    });
+                    if (isActive) {
+                        _activeItemKeys.push(item.key);
+                        _activeItems.push(item);
+                    }
+                }
+                if (item.isEnabled) {
+                    const isEnabled = item.isEnabled({
+                        editor,
+                        editorConfigContext,
+                        selection
+                    });
+                    if (isEnabled) {
+                        _enabledItemKeys.push(item.key);
+                    }
+                } else {
+                    _enabledItemKeys.push(item.key);
+                }
+            }
+            setActiveItemKeys(_activeItemKeys);
+            setEnabledItemKeys(_enabledItemKeys);
+            if (onActiveChange) {
+                onActiveChange({
+                    activeItems: _activeItems
+                });
+            }
+        });
+    }, [
+        editor,
+        editorConfigContext,
+        items,
+        maxActiveItems,
+        onActiveChange
+    ]);
+    useEffect(()=>{
+        updateStates();
+    }, [
+        updateStates
+    ]);
+    useEffect(()=>{
+        document.addEventListener('mouseup', updateStates);
+        return ()=>{
+            document.removeEventListener('mouseup', updateStates);
+        };
+    }, [
+        updateStates
+    ]);
+    useEffect(()=>{
+        return mergeRegister(editor.registerUpdateListener(()=>{
+            updateStates();
+        }));
+    }, [
+        editor,
+        updateStates
+    ]);
+    return /*#__PURE__*/ _jsx(DropDown, {
+        Icon: Icon,
+        buttonAriaLabel: `${groupKey} dropdown`,
+        buttonClassName: [
+            baseClass,
+            `${baseClass}-${groupKey}`,
+            ...classNames || []
+        ].filter(Boolean).join(' '),
+        itemsContainerClassNames: [
+            `${baseClass}-items`,
+            ...itemsContainerClassNames || []
+        ],
+        label: label,
+        children: items.length && items.map((item)=>{
+            return /*#__PURE__*/ _jsx(ToolbarItem, {
+                active: activeItemKeys.includes(item.key),
+                anchorElem: anchorElem,
+                editor: editor,
+                enabled: enabledItemKeys.includes(item.key),
+                item: item
+            }, item.key);
+        })
+    }, groupKey);
+};
+
+//# sourceMappingURL=index.js.map

package/dist/features/toolbars/shared/ToolbarDropdown/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/features/toolbars/shared/ToolbarDropdown/index.tsx"],"sourcesContent":["'use client'\nimport React, { useCallback, useEffect } from 'react'\n\nconst baseClass = 'toolbar-popup__dropdown'\n\nimport type { LexicalEditor } from 'lexical'\n\nimport { mergeRegister } from '@lexical/utils'\nimport { useTranslation } from '@payloadcms/ui'\nimport { $getSelection } from 'lexical'\n\nimport type { ToolbarGroupItem } from '../../types.js'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport { DropDown, DropDownItem } from './DropDown.js'\nimport './index.scss'\n\nconst ToolbarItem = ({\n  active,\n  anchorElem,\n  editor,\n  enabled,\n  item,\n}: {\n  active?: boolean\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  enabled?: boolean\n  item: ToolbarGroupItem\n}) => {\n  const { i18n } = useTranslation()\n\n  if (item.Component) {\n    return (\n      item?.Component && (\n        <item.Component\n          active={active}\n          anchorElem={anchorElem}\n          editor={editor}\n          enabled={enabled}\n          item={item}\n          key={item.key}\n        />\n      )\n    )\n  }\n\n  let title = item.key\n  if (item.label) {\n    title = typeof item.label === 'function' ? item.label({ i18n }) : item.label\n  }\n  // Crop title to max. 25 characters\n  if (title.length > 25) {\n    title = title.substring(0, 25) + '...'\n  }\n\n  return (\n    <DropDownItem active={active} editor={editor} enabled={enabled} item={item} key={item.key}>\n      {item?.ChildComponent && <item.ChildComponent />}\n      <span className=\"text\">{title}</span>\n    </DropDownItem>\n  )\n}\n\nexport const ToolbarDropdown = ({\n  Icon,\n  anchorElem,\n  classNames,\n  editor,\n  groupKey,\n  items,\n  itemsContainerClassNames,\n  label,\n  maxActiveItems,\n  onActiveChange,\n}: {\n  Icon?: React.FC\n  anchorElem: HTMLElement\n  classNames?: string[]\n  editor: LexicalEditor\n  groupKey: string\n  items: ToolbarGroupItem[]\n  itemsContainerClassNames?: string[]\n  label?: string\n  /**\n   * Maximum number of active items allowed. This is a performance optimization to prevent\n   * unnecessary item active checks when the maximum number of active items is reached.\n   */\n  maxActiveItems?: number\n  onActiveChange?: ({ activeItems }: { activeItems: ToolbarGroupItem[] }) => void\n}) => {\n  const [activeItemKeys, setActiveItemKeys] = React.useState<string[]>([])\n  const [enabledItemKeys, setEnabledItemKeys] = React.useState<string[]>([])\n  const editorConfigContext = useEditorConfigContext()\n\n  const updateStates = useCallback(() => {\n    editor.getEditorState().read(() => {\n      const selection = $getSelection()\n\n      const _activeItemKeys: string[] = []\n      const _activeItems: ToolbarGroupItem[] = []\n      const _enabledItemKeys: string[] = []\n\n      for (const item of items) {\n        if (item.isActive && (!maxActiveItems || _activeItemKeys.length < maxActiveItems)) {\n          const isActive = item.isActive({ editor, editorConfigContext, selection })\n          if (isActive) {\n            _activeItemKeys.push(item.key)\n            _activeItems.push(item)\n          }\n        }\n        if (item.isEnabled) {\n          const isEnabled = item.isEnabled({ editor, editorConfigContext, selection })\n          if (isEnabled) {\n            _enabledItemKeys.push(item.key)\n          }\n        } else {\n          _enabledItemKeys.push(item.key)\n        }\n      }\n      setActiveItemKeys(_activeItemKeys)\n      setEnabledItemKeys(_enabledItemKeys)\n\n      if (onActiveChange) {\n        onActiveChange({ activeItems: _activeItems })\n      }\n    })\n  }, [editor, editorConfigContext, items, maxActiveItems, onActiveChange])\n\n  useEffect(() => {\n    updateStates()\n  }, [updateStates])\n\n  useEffect(() => {\n    document.addEventListener('mouseup', updateStates)\n    return () => {\n      document.removeEventListener('mouseup', updateStates)\n    }\n  }, [updateStates])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updateStates()\n      }),\n    )\n  }, [editor, updateStates])\n\n  return (\n    <DropDown\n      Icon={Icon}\n      buttonAriaLabel={`${groupKey} dropdown`}\n      buttonClassName={[baseClass, `${baseClass}-${groupKey}`, ...(classNames || [])]\n        .filter(Boolean)\n        .join(' ')}\n      itemsContainerClassNames={[`${baseClass}-items`, ...(itemsContainerClassNames || [])]}\n      key={groupKey}\n      label={label}\n    >\n      {items.length &&\n        items.map((item) => {\n          return (\n            <ToolbarItem\n              active={activeItemKeys.includes(item.key)}\n              anchorElem={anchorElem}\n              editor={editor}\n              enabled={enabledItemKeys.includes(item.key)}\n              item={item}\n              key={item.key}\n            />\n          )\n        })}\n    </DropDown>\n  )\n}\n"],"names":["React","useCallback","useEffect","baseClass","mergeRegister","useTranslation","$getSelection","useEditorConfigContext","DropDown","DropDownItem","ToolbarItem","active","anchorElem","editor","enabled","item","i18n","Component","key","title","label","length","substring","ChildComponent","span","className","ToolbarDropdown","Icon","classNames","groupKey","items","itemsContainerClassNames","maxActiveItems","onActiveChange","activeItemKeys","setActiveItemKeys","useState","enabledItemKeys","setEnabledItemKeys","editorConfigContext","updateStates","getEditorState","read","selection","_activeItemKeys","_activeItems","_enabledItemKeys","isActive","push","isEnabled","activeItems","document","addEventListener","removeEventListener","registerUpdateListener","buttonAriaLabel","buttonClassName","filter","Boolean","join","map","includes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/features/toolbars/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/features/toolbars/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC3D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAA;AAElG,MAAM,MAAM,YAAY,GACpB;IACE,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;CACjB,GACD;IACE,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,oIAAoI;IACpI,SAAS,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,CAAC,EAAE,OAAO,CAAA;QAChB,UAAU,EAAE,WAAW,CAAA;QACvB,MAAM,EAAE,aAAa,CAAA;QACrB,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,IAAI,EAAE,gBAAgB,CAAA;KACvB,CAAC,CAAA;IACF,QAAQ,CAAC,EAAE,CAAC,EACV,MAAM,EACN,mBAAmB,EACnB,SAAS,GACV,EAAE;QACD,MAAM,EAAE,aAAa,CAAA;QACrB,mBAAmB,EAAE,uBAAuB,CAAA;QAC5C,SAAS,EAAE,aAAa,CAAA;KACzB,KAAK,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,CAAC,EACX,MAAM,EACN,mBAAmB,EACnB,SAAS,GACV,EAAE;QACD,MAAM,EAAE,aAAa,CAAA;QACrB,mBAAmB,EAAE,uBAAuB,CAAA;QAC5C,SAAS,EAAE,aAAa,CAAA;KACzB,KAAK,OAAO,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,6EAA6E;IAC7E,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,UAAU,CAAC,EAAE,EAAE,MAAM,CAAC,CAAA;KAAE,KAAK,MAAM,CAAC,GAAG,MAAM,CAAA;IACzE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACvF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA"}

package/dist/features/toolbars/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/toolbars/types.ts"],"sourcesContent":["import type { I18nClient } from '@payloadcms/translations'\nimport type { BaseSelection, LexicalEditor } from 'lexical'\nimport type React from 'react'\n\nimport type { EditorConfigContextType } from '../../lexical/config/client/EditorConfigProvider.js'\n\nexport type ToolbarGroup =\n  | {\n      ChildComponent?: React.FC\n      items: Array<ToolbarGroupItem>\n      key: string\n      order?: number\n      type: 'dropdown'\n    }\n  | {\n      items: Array<ToolbarGroupItem>\n      key: string\n      order?: number\n      type: 'buttons'\n    }\n\nexport type ToolbarGroupItem = {\n  ChildComponent?: React.FC\n  /** Use component to ignore the children and onClick properties. It does not use the default, pre-defined format Button component */\n  Component?: React.FC<{\n    active?: boolean\n    anchorElem: HTMLElement\n    editor: LexicalEditor\n    enabled?: boolean\n    item: ToolbarGroupItem\n  }>\n  isActive?: ({\n    editor,\n    editorConfigContext,\n    selection,\n  }: {\n    editor: LexicalEditor\n    editorConfigContext: EditorConfigContextType\n    selection: BaseSelection\n  }) => boolean\n  isEnabled?: ({\n    editor,\n    editorConfigContext,\n    selection,\n  }: {\n    editor: LexicalEditor\n    editorConfigContext: EditorConfigContextType\n    selection: BaseSelection\n  }) => boolean\n  key: string\n  /** The label is displayed as text if the item is part of a dropdown group */\n  label?: (({ i18n }: { i18n: I18nClient<{}, string> }) => string) | string\n  onSelect?: ({ editor, isActive }: { editor: LexicalEditor; isActive: boolean }) => void\n  order?: number\n}\n"],"names":[],"rangeMappings":"","mappings":"AAqBA,WAiCC"}

package/dist/features/typeUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtilities.d.ts","sourceRoot":"","sources":["../../src/features/typeUtilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,SAAS,WAAW,EACjD,IAAI,EAAE,aAAa,CAAC,IAAI,CAAC,GACxB,aAAa,CAAC,IAAI,CAAC,CAErB"}

package/dist/features/typeUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/features/typeUtilities.ts"],"sourcesContent":["import type { LexicalNode } from 'lexical'\n\nimport type { NodeWithHooks } from './types.js'\n\n/**\n * Utility function to create a node with hooks. You don't have to use this utility, but it improves type inference\n * @param node the node\n */\nexport function createNode<Node extends LexicalNode>(\n  node: NodeWithHooks<Node>,\n): NodeWithHooks<Node> {\n  return node\n}\n"],"names":["createNode","node"],"rangeMappings":";;;;;","mappings":"AAIA;;;CAGC,GACD,OAAO,SAASA,WACdC,IAAyB;IAEzB,OAAOA;AACT"}

package/dist/features/types.d.ts

@@ -0,0 +1,468 @@
+import type { Transformer } from '@lexical/markdown';
+import type { GenericLanguages, I18nClient } from '@payloadcms/translations';
+import type { JSONSchema4 } from 'json-schema';
+import type { Klass, LexicalEditor, LexicalNode, LexicalNodeReplacement, SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { Field, PayloadRequestWithData, ReplaceAny, RequestContext, RichTextField, SanitizedConfig, ValidateOptions } from 'payload';
+import type React from 'react';
+import type { ClientEditorConfig, ServerEditorConfig } from '../lexical/config/types.js';
+import type { SlashMenuGroup } from '../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
+import type { AdapterProps } from '../types.js';
+import type { HTMLConverter } from './converters/html/converter/types.js';
+import type { ToolbarGroup } from './toolbars/types.js';
+export type PopulationPromise<T extends SerializedLexicalNode = SerializedLexicalNode> = ({ context, currentDepth, depth, draft, editorPopulationPromises, field, fieldPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, }: {
+    context: RequestContext;
+    currentDepth: number;
+    depth: number;
+    draft: boolean;
+    /**
+     * This maps all population promises to the node type
+     */
+    editorPopulationPromises: Map<string, Array<PopulationPromise>>;
+    field: RichTextField<SerializedEditorState, AdapterProps>;
+    /**
+     * fieldPromises are used for things like field hooks. They will be awaited before awaiting populationPromises
+     */
+    fieldPromises: Promise<void>[];
+    findMany: boolean;
+    flattenLocales: boolean;
+    node: T;
+    overrideAccess: boolean;
+    populationPromises: Promise<void>[];
+    req: PayloadRequestWithData;
+    showHiddenFields: boolean;
+    siblingDoc: Record<string, unknown>;
+}) => void;
+export type NodeValidation<T extends SerializedLexicalNode = SerializedLexicalNode> = ({ node, nodeValidations, validation, }: {
+    node: T;
+    nodeValidations: Map<string, Array<NodeValidation>>;
+    validation: {
+        options: ValidateOptions<unknown, unknown, RichTextField>;
+        value: SerializedEditorState;
+    };
+}) => Promise<string | true> | string | true;
+export type FeatureProviderProviderServer<ServerFeatureProps, ClientFeatureProps> = (props?: ServerFeatureProps) => FeatureProviderServer<ServerFeatureProps, ClientFeatureProps>;
+export type FeatureProviderServer<ServerFeatureProps, ClientFeatureProps> = {
+    /** Keys of dependencies needed for this feature. These dependencies do not have to be loaded first */
+    dependencies?: string[];
+    /** Keys of priority dependencies needed for this feature. These dependencies have to be loaded first and are available in the `feature` property*/
+    dependenciesPriority?: string[];
+    /** Keys of soft-dependencies needed for this feature. The FeatureProviders dependencies are optional, but are considered as last-priority in the loading process */
+    dependenciesSoft?: string[];
+    /**
+     * This is being called during the payload sanitization process
+     */
+    feature: (props: {
+        config: SanitizedConfig;
+        /** unSanitizedEditorConfig.features, but mapped */
+        featureProviderMap: ServerFeatureProviderMap;
+        isRoot?: boolean;
+        resolvedFeatures: ResolvedServerFeatureMap;
+        unSanitizedEditorConfig: ServerEditorConfig;
+    }) => Promise<ServerFeature<ServerFeatureProps, ClientFeatureProps>> | ServerFeature<ServerFeatureProps, ClientFeatureProps>;
+    key: string;
+    /** Props which were passed into your feature will have to be passed here. This will allow them to be used / read in other places of the code, e.g. wherever you can use useEditorConfigContext */
+    serverFeatureProps: ServerFeatureProps;
+};
+export type FeatureProviderProviderClient<ClientFeatureProps> = (props: ClientComponentProps<ClientFeatureProps>) => FeatureProviderClient<ClientFeatureProps>;
+/**
+ * No dependencies => Features need to be sorted on the server first, then sent to client in right order
+ */
+export type FeatureProviderClient<ClientFeatureProps> = {
+    /**
+     * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to
+     */
+    clientFeatureProps: ClientComponentProps<ClientFeatureProps>;
+    feature: (props: {
+        clientFunctions: Record<string, any>;
+        /** unSanitizedEditorConfig.features, but mapped */
+        featureProviderMap: ClientFeatureProviderMap;
+        resolvedFeatures: ResolvedClientFeatureMap;
+        unSanitizedEditorConfig: ClientEditorConfig;
+    }) => ClientFeature<ClientFeatureProps>;
+};
+export type PluginComponent<ClientFeatureProps = any> = React.FC<{
+    clientProps: ClientFeatureProps;
+}>;
+export type PluginComponentWithAnchor<ClientFeatureProps = any> = React.FC<{
+    anchorElem: HTMLElement;
+    clientProps: ClientFeatureProps;
+}>;
+export type ClientFeature<ClientFeatureProps> = {
+    /**
+     * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to
+     */
+    clientFeatureProps: ClientComponentProps<ClientFeatureProps>;
+    hooks?: {
+        load?: ({ incomingEditorState, }: {
+            incomingEditorState: SerializedEditorState;
+        }) => SerializedEditorState;
+        save?: ({ incomingEditorState, }: {
+            incomingEditorState: SerializedEditorState;
+        }) => SerializedEditorState;
+    };
+    markdownTransformers?: Transformer[];
+    nodes?: Array<Klass<LexicalNode> | LexicalNodeReplacement>;
+    /**
+     * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+     */
+    plugins?: Array<{
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'aboveContainer';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'bottom';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'normal';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'top';
+    } | {
+        Component: PluginComponentWithAnchor<ClientFeatureProps>;
+        position: 'floatingAnchorElem';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'belowContainer';
+    }>;
+    slashMenu?: {
+        /**
+         * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).
+         * Thus, to re-calculate the available groups, this function will be called every time you type after the /.
+         *
+         * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.
+         */
+        dynamicGroups?: ({ editor, queryString, }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[];
+        /**
+         * Static array of groups together with the items in them. These will always be present.
+         * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.
+         */
+        groups?: SlashMenuGroup[];
+    };
+    /**
+     * An opt-in, classic fixed toolbar which stays at the top of the editor
+     */
+    toolbarFixed?: {
+        groups: ToolbarGroup[];
+    };
+    /**
+     * The default, floating toolbar which appears when you select text.
+     */
+    toolbarInline?: {
+        /**
+         * Array of toolbar groups / sections. Each section can contain multiple toolbar items.
+         */
+        groups: ToolbarGroup[];
+    };
+};
+export type ClientComponentProps<ClientFeatureProps> = ClientFeatureProps extends undefined ? {
+    featureKey: string;
+    order: number;
+} : {
+    featureKey: string;
+    order: number;
+} & ClientFeatureProps;
+export type AfterReadNodeHookArgs<T extends SerializedLexicalNode> = {
+    /**
+     * Only available in `afterRead` hooks.
+     */
+    currentDepth: number;
+    /**
+     * Only available in `afterRead` hooks.
+     */
+    depth: number;
+    draft: boolean;
+    fallbackLocale: string;
+    /**
+     *  Only available in `afterRead` field hooks.
+     */
+    fieldPromises: Promise<void>[];
+    /** Boolean to denote if this hook is running against finding one, or finding many within the afterRead hook. */
+    findMany: boolean;
+    flattenLocales: boolean;
+    /**
+     * The requested locale.
+     */
+    locale: string;
+    overrideAccess: boolean;
+    /**
+     *  Only available in `afterRead` field hooks.
+     */
+    populationPromises: Promise<void>[];
+    /**
+     * Only available in `afterRead` hooks.
+     */
+    showHiddenFields: boolean;
+    /**
+     * Only available in `afterRead` hooks.
+     */
+    triggerAccessControl: boolean;
+    /**
+     * Only available in `afterRead` hooks.
+     */
+    triggerHooks: boolean;
+};
+export type AfterChangeNodeHookArgs<T extends SerializedLexicalNode> = {
+    /** A string relating to which operation the field type is currently executing within. Useful within beforeValidate, beforeChange, and afterChange hooks to differentiate between create and update operations. */
+    operation: 'create' | 'delete' | 'read' | 'update';
+    /** The value of the node before any changes. Not available in afterRead hooks */
+    originalNode: T;
+};
+export type BeforeValidateNodeHookArgs<T extends SerializedLexicalNode> = {
+    /** A string relating to which operation the field type is currently executing within. Useful within beforeValidate, beforeChange, and afterChange hooks to differentiate between create and update operations. */
+    operation: 'create' | 'delete' | 'read' | 'update';
+    /** The value of the node before any changes. Not available in afterRead hooks */
+    originalNode: T;
+    overrideAccess: boolean;
+};
+export type BeforeChangeNodeHookArgs<T extends SerializedLexicalNode> = {
+    duplicate: boolean;
+    /**
+     * Only available in `beforeChange` hooks.
+     */
+    errors: {
+        field: string;
+        message: string;
+    }[];
+    mergeLocaleActions: (() => Promise<void>)[];
+    /** A string relating to which operation the field type is currently executing within. Useful within beforeValidate, beforeChange, and afterChange hooks to differentiate between create and update operations. */
+    operation: 'create' | 'delete' | 'read' | 'update';
+    /** The value of the node before any changes. Not available in afterRead hooks */
+    originalNode: T;
+    /**
+     * The original node with locales (not modified by any hooks).
+     */
+    originalNodeWithLocales?: T;
+    skipValidation: boolean;
+};
+export type BaseNodeHookArgs<T extends SerializedLexicalNode> = {
+    context: RequestContext;
+    /** The value of the node. */
+    node: T;
+    parentRichTextFieldPath: (number | string)[];
+    parentRichTextFieldSchemaPath: string[];
+    /** The payload request object. It is mocked for Local API operations. */
+    req: PayloadRequestWithData;
+};
+export type AfterReadNodeHook<T extends SerializedLexicalNode> = (args: AfterReadNodeHookArgs<T> & BaseNodeHookArgs<T>) => Promise<T> | T;
+export type AfterChangeNodeHook<T extends SerializedLexicalNode> = (args: AfterChangeNodeHookArgs<T> & BaseNodeHookArgs<T>) => Promise<T> | T;
+export type BeforeChangeNodeHook<T extends SerializedLexicalNode> = (args: BeforeChangeNodeHookArgs<T> & BaseNodeHookArgs<T>) => Promise<T> | T;
+export type BeforeValidateNodeHook<T extends SerializedLexicalNode> = (args: BeforeValidateNodeHookArgs<T> & BaseNodeHookArgs<T>) => Promise<T> | T;
+export type NodeWithHooks<T extends LexicalNode = any> = {
+    converters?: {
+        html?: HTMLConverter<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>;
+    };
+    /**
+     * If a node includes sub-fields (e.g. block and link nodes), passing those subFields here will make payload
+     * automatically populate & run hooks for them
+     */
+    getSubFields?: (args: {
+        node: ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>;
+        req: PayloadRequestWithData;
+    }) => Field[] | null;
+    getSubFieldsData?: (args: {
+        node: ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>;
+        req: PayloadRequestWithData;
+    }) => Record<string, unknown>;
+    graphQLPopulationPromises?: Array<PopulationPromise<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+    hooks?: {
+        afterChange?: Array<AfterChangeNodeHook<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+        afterRead?: Array<AfterReadNodeHook<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+        beforeChange?: Array<BeforeChangeNodeHook<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+        beforeValidate?: Array<BeforeValidateNodeHook<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+    };
+    node: Klass<T> | LexicalNodeReplacement;
+    validations?: Array<NodeValidation<ReturnType<ReplaceAny<T, LexicalNode>['exportJSON']>>>;
+};
+export type ServerFeature<ServerProps, ClientFeatureProps> = {
+    ClientComponent?: React.FC<ClientComponentProps<ClientFeatureProps>>;
+    /**
+     * This determines what props will be available on the Client.
+     */
+    clientFeatureProps?: ClientFeatureProps;
+    generateComponentMap?: (args: {
+        config: SanitizedConfig;
+        i18n: I18nClient;
+        props: ServerProps;
+        schemaPath: string;
+    }) => {
+        [key: string]: React.FC<{
+            componentKey: string;
+            featureKey: string;
+        }>;
+    };
+    generateSchemaMap?: (args: {
+        config: SanitizedConfig;
+        i18n: I18nClient;
+        props: ServerProps;
+        schemaMap: Map<string, Field[]>;
+        schemaPath: string;
+    }) => Map<string, Field[]> | null;
+    generatedTypes?: {
+        modifyOutputSchema: ({ collectionIDFieldTypes, config, currentSchema, field, interfaceNameDefinitions, isRequired, }: {
+            collectionIDFieldTypes: {
+                [key: string]: 'number' | 'string';
+            };
+            config?: SanitizedConfig;
+            /**
+             * Current schema which will be modified by this function.
+             */
+            currentSchema: JSONSchema4;
+            field: RichTextField<SerializedEditorState, AdapterProps>;
+            /**
+             * Allows you to define new top-level interfaces that can be re-used in the output schema.
+             */
+            interfaceNameDefinitions: Map<string, JSONSchema4>;
+            isRequired: boolean;
+        }) => JSONSchema4;
+    };
+    /**
+     * Here you can provide i18n translations for your feature. These will only be available on the server and client.
+     *
+     * Translations here are automatically scoped to `lexical.featureKey.yourKey`
+     *
+     * @Example
+     * ```ts
+     * i18n: {
+     *   en: {
+     *     label: 'Horizontal Rule',
+     *   },
+     *   de: {
+     *     label: 'Trennlinie',
+     *   },
+     * }
+     * ```
+     * In order to access these translations, you would use `i18n.t('lexical:horizontalRule:label')`.
+     */
+    i18n?: Partial<GenericLanguages>;
+    markdownTransformers?: Transformer[];
+    nodes?: Array<NodeWithHooks>;
+    /** Props which were passed into your feature will have to be passed here. This will allow them to be used / read in other places of the code, e.g. wherever you can use useEditorConfigContext */
+    serverFeatureProps: ServerProps;
+};
+export type ResolvedServerFeature<ServerProps, ClientFeatureProps> = ServerFeature<ServerProps, ClientFeatureProps> & Required<Pick<FeatureProviderServer<ServerProps, ClientFeatureProps>, 'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'>> & {
+    order: number;
+};
+export type ResolvedClientFeature<ClientFeatureProps> = ClientFeature<ClientFeatureProps> & {
+    key: string;
+    order: number;
+};
+export type ResolvedServerFeatureMap = Map<string, ResolvedServerFeature<unknown, unknown>>;
+export type ResolvedClientFeatureMap = Map<string, ResolvedClientFeature<unknown>>;
+export type ServerFeatureProviderMap = Map<string, FeatureProviderServer<unknown, unknown>>;
+export type ClientFeatureProviderMap = Map<string, FeatureProviderClient<unknown>>;
+/**
+ * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+ */
+export type SanitizedPlugin = {
+    Component: PluginComponent;
+    clientProps: any;
+    key: string;
+    position: 'bottom';
+} | {
+    Component: PluginComponent;
+    clientProps: any;
+    key: string;
+    position: 'normal';
+} | {
+    Component: PluginComponent;
+    clientProps: any;
+    key: string;
+    position: 'top';
+} | {
+    Component: PluginComponentWithAnchor;
+    clientProps: any;
+    desktopOnly?: boolean;
+    key: string;
+    position: 'floatingAnchorElem';
+} | {
+    Component: PluginComponent;
+    clientProps: any;
+    key: string;
+    position: 'aboveContainer';
+} | {
+    Component: PluginComponent;
+    clientProps: any;
+    key: string;
+    position: 'belowContainer';
+};
+export type SanitizedServerFeatures = Required<Pick<ResolvedServerFeature<unknown, unknown>, 'i18n' | 'markdownTransformers' | 'nodes'>> & {
+    /**  The node types mapped to their converters */
+    converters: {
+        html: HTMLConverter[];
+    };
+    /** The keys of all enabled features */
+    enabledFeatures: string[];
+    generatedTypes: {
+        modifyOutputSchemas: Array<({ collectionIDFieldTypes, config, currentSchema, field, interfaceNameDefinitions, isRequired, }: {
+            collectionIDFieldTypes: {
+                [key: string]: 'number' | 'string';
+            };
+            config?: SanitizedConfig;
+            /**
+             * Current schema which will be modified by this function.
+             */
+            currentSchema: JSONSchema4;
+            field: RichTextField<SerializedEditorState, AdapterProps>;
+            /**
+             * Allows you to define new top-level interfaces that can be re-used in the output schema.
+             */
+            interfaceNameDefinitions: Map<string, JSONSchema4>;
+            isRequired: boolean;
+        }) => JSONSchema4>;
+    };
+    /**  The node types mapped to their hooks */
+    getSubFields?: Map<string, (args: {
+        node: SerializedLexicalNode;
+        req: PayloadRequestWithData;
+    }) => Field[] | null>;
+    getSubFieldsData?: Map<string, (args: {
+        node: SerializedLexicalNode;
+        req: PayloadRequestWithData;
+    }) => Record<string, unknown>>;
+    graphQLPopulationPromises: Map<string, Array<PopulationPromise>>;
+    hooks?: {
+        afterChange?: Map<string, Array<AfterChangeNodeHook<SerializedLexicalNode>>>;
+        afterRead?: Map<string, Array<AfterReadNodeHook<SerializedLexicalNode>>>;
+        beforeChange?: Map<string, Array<BeforeChangeNodeHook<SerializedLexicalNode>>>;
+        beforeValidate?: Map<string, Array<BeforeValidateNodeHook<SerializedLexicalNode>>>;
+    }; /**  The node types mapped to their populationPromises */
+    /**  The node types mapped to their validations */
+    validations: Map<string, Array<NodeValidation>>;
+};
+export type SanitizedClientFeatures = Required<Pick<ResolvedClientFeature<unknown>, 'markdownTransformers' | 'nodes' | 'toolbarFixed' | 'toolbarInline'>> & {
+    /** The keys of all enabled features */
+    enabledFeatures: string[];
+    hooks: {
+        load: Array<({ incomingEditorState, }: {
+            incomingEditorState: SerializedEditorState;
+        }) => SerializedEditorState>;
+        save: Array<({ incomingEditorState, }: {
+            incomingEditorState: SerializedEditorState;
+        }) => SerializedEditorState>;
+    };
+    /**
+     * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+     */
+    plugins?: Array<SanitizedPlugin>;
+    slashMenu: {
+        /**
+         * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).
+         * Thus, to re-calculate the available groups, this function will be called every time you type after the /.
+         *
+         * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.
+         */
+        dynamicGroups: Array<({ editor, queryString }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[]>;
+        /**
+         * Static array of groups together with the items in them. These will always be present.
+         * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.
+         */
+        groups: SlashMenuGroup[];
+    };
+};
+//# sourceMappingURL=types.d.ts.map