@payloadcms/richtext-lexical 3.0.0-beta.78 → 3.0.0-beta.80

package/dist/features/toolbars/fixed/Toolbar/index.js

@@ -1,207 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
-import { useScrollInfo, useThrottledEffect, useTranslation } from '@payloadcms/ui';
-import * as React from 'react';
-import { useMemo } from 'react';
-import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
-import { ToolbarButton } from '../../shared/ToolbarButton/index.js';
-import { ToolbarDropdown } from '../../shared/ToolbarDropdown/index.js';
-function ButtonGroupItem({ anchorElem, editor, item }) {
-    if (item.Component) {
-        return item?.Component && /*#__PURE__*/ _jsx(item.Component, {
-            anchorElem: anchorElem,
-            editor: editor,
-            item: item
-        }, item.key);
-    }
-    return /*#__PURE__*/ _jsx(ToolbarButton, {
-        editor: editor,
-        item: item,
-        children: item?.ChildComponent && /*#__PURE__*/ _jsx(item.ChildComponent, {})
-    }, item.key);
-}
-function ToolbarGroupComponent({ anchorElem, editor, editorConfig, group, index }) {
-    const { i18n } = useTranslation();
-    const [dropdownLabel, setDropdownLabel] = React.useState(null);
-    const [DropdownIcon, setDropdownIcon] = React.useState(null);
-    React.useEffect(()=>{
-        if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {
-            setDropdownIcon(()=>group.ChildComponent);
-        } else {
-            setDropdownIcon(null);
-        }
-    }, [
-        group
-    ]);
-    const onActiveChange = ({ activeItems })=>{
-        if (!activeItems.length) {
-            if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {
-                setDropdownIcon(()=>group.ChildComponent);
-                setDropdownLabel(null);
-            } else {
-                setDropdownIcon(null);
-                setDropdownLabel(null);
-            }
-            return;
-        }
-        const item = activeItems[0];
-        let label = item.key;
-        if (item.label) {
-            label = typeof item.label === 'function' ? item.label({
-                i18n
-            }) : item.label;
-        }
-        // Crop title to max. 25 characters
-        if (label.length > 25) {
-            label = label.substring(0, 25) + '...';
-        }
-        setDropdownLabel(label);
-        setDropdownIcon(()=>item.ChildComponent);
-    };
-    return /*#__PURE__*/ _jsxs("div", {
-        className: `fixed-toolbar__group fixed-toolbar__group-${group.key}`,
-        children: [
-            group.type === 'dropdown' && group.items.length && (DropdownIcon ? /*#__PURE__*/ _jsx(ToolbarDropdown, {
-                Icon: DropdownIcon,
-                anchorElem: anchorElem,
-                editor: editor,
-                groupKey: group.key,
-                items: group.items,
-                itemsContainerClassNames: [
-                    'fixed-toolbar__dropdown-items'
-                ],
-                label: dropdownLabel,
-                maxActiveItems: 1,
-                onActiveChange: onActiveChange
-            }) : /*#__PURE__*/ _jsx(ToolbarDropdown, {
-                anchorElem: anchorElem,
-                editor: editor,
-                groupKey: group.key,
-                items: group.items,
-                itemsContainerClassNames: [
-                    'fixed-toolbar__dropdown-items'
-                ],
-                label: dropdownLabel,
-                maxActiveItems: 1,
-                onActiveChange: onActiveChange
-            })),
-            group.type === 'buttons' && group.items.length && group.items.map((item)=>{
-                return /*#__PURE__*/ _jsx(ButtonGroupItem, {
-                    anchorElem: anchorElem,
-                    editor: editor,
-                    item: item
-                }, item.key);
-            }),
-            index < editorConfig.features.toolbarFixed?.groups.length - 1 && /*#__PURE__*/ _jsx("div", {
-                className: "divider"
-            })
-        ]
-    }, group.key);
-}
-function FixedToolbar({ anchorElem, clientProps, editor, editorConfig, parentWithFixedToolbar }) {
-    const currentToolbarRef = React.useRef(null);
-    const { y } = useScrollInfo();
-    // Memoize the parent toolbar element
-    const parentToolbarElem = useMemo(()=>{
-        if (!parentWithFixedToolbar || clientProps?.disableIfParentHasFixedToolbar) {
-            return null;
-        }
-        const parentEditorElem = parentWithFixedToolbar.editorContainerRef.current;
-        let sibling = parentEditorElem.previousElementSibling;
-        while(sibling){
-            if (sibling.classList.contains('fixed-toolbar')) {
-                return sibling;
-            }
-            sibling = sibling.previousElementSibling;
-        }
-        return null;
-    }, [
-        clientProps?.disableIfParentHasFixedToolbar,
-        parentWithFixedToolbar
-    ]);
-    useThrottledEffect(()=>{
-        if (!parentToolbarElem) {
-            // this also checks for clientProps?.disableIfParentHasFixedToolbar indirectly, see the parentToolbarElem useMemo
-            return;
-        }
-        const currentToolbarElem = currentToolbarRef.current;
-        if (!currentToolbarElem) {
-            return;
-        }
-        const currentRect = currentToolbarElem.getBoundingClientRect();
-        const parentRect = parentToolbarElem.getBoundingClientRect();
-        // we only need to check for vertical overlap
-        const overlapping = !(currentRect.bottom < parentRect.top || currentRect.top > parentRect.bottom);
-        if (overlapping) {
-            currentToolbarRef.current.className = 'fixed-toolbar fixed-toolbar--overlapping';
-            parentToolbarElem.className = 'fixed-toolbar fixed-toolbar--hide';
-        } else {
-            if (!currentToolbarRef.current.classList.contains('fixed-toolbar--overlapping')) {
-                return;
-            }
-            currentToolbarRef.current.className = 'fixed-toolbar';
-            parentToolbarElem.className = 'fixed-toolbar';
-        }
-    }, 50, [
-        currentToolbarRef,
-        parentToolbarElem,
-        y
-    ]);
-    return /*#__PURE__*/ _jsx("div", {
-        className: "fixed-toolbar",
-        onFocus: (event)=>{
-            // Prevent other focus events being triggered. Otherwise, if this was to be clicked while in a child editor,
-            // the parent editor will be focused, and the child editor will lose focus.
-            event.stopPropagation();
-        },
-        ref: currentToolbarRef,
-        children: editor.isEditable() && /*#__PURE__*/ _jsx(React.Fragment, {
-            children: editorConfig?.features && editorConfig.features?.toolbarFixed?.groups.map((group, i)=>{
-                return /*#__PURE__*/ _jsx(ToolbarGroupComponent, {
-                    anchorElem: anchorElem,
-                    editor: editor,
-                    editorConfig: editorConfig,
-                    group: group,
-                    index: i
-                }, group.key);
-            })
-        })
-    });
-}
-const getParentEditorWithFixedToolbar = (editorConfigContext)=>{
-    if (editorConfigContext.parentEditor?.editorConfig) {
-        if (editorConfigContext.parentEditor?.editorConfig.resolvedFeatureMap.has('toolbarFixed')) {
-            return editorConfigContext.parentEditor;
-        } else {
-            if (editorConfigContext.parentEditor) {
-                return getParentEditorWithFixedToolbar(editorConfigContext.parentEditor);
-            }
-        }
-    }
-    return false;
-};
-export const FixedToolbarPlugin = ({ anchorElem, clientProps })=>{
-    const [currentEditor] = useLexicalComposerContext();
-    const editorConfigContext = useEditorConfigContext();
-    const { editorConfig: currentEditorConfig } = editorConfigContext;
-    const editor = clientProps.applyToFocusedEditor ? editorConfigContext.focusedEditor?.editor || currentEditor : currentEditor;
-    const editorConfig = clientProps.applyToFocusedEditor ? editorConfigContext.focusedEditor?.editorConfig || currentEditorConfig : currentEditorConfig;
-    const parentWithFixedToolbar = getParentEditorWithFixedToolbar(editorConfigContext);
-    if (clientProps?.disableIfParentHasFixedToolbar) {
-        if (parentWithFixedToolbar) {
-            return null;
-        }
-    }
-    if (!editorConfig?.features?.toolbarFixed?.groups?.length) {
-        return null;
-    }
-    return /*#__PURE__*/ _jsx(FixedToolbar, {
-        anchorElem: anchorElem,
-        editor: editor,
-        editorConfig: editorConfig,
-        parentWithFixedToolbar: parentWithFixedToolbar
-    });
-};
-
-//# sourceMappingURL=index.js.map

package/dist/features/toolbars/fixed/Toolbar/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/features/toolbars/fixed/Toolbar/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { useScrollInfo, useThrottledEffect, useTranslation } from '@payloadcms/ui'\nimport * as React from 'react'\nimport { useMemo } from 'react'\n\nimport type { EditorConfigContextType } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport type { SanitizedClientEditorConfig } from '../../../../lexical/config/types.js'\nimport type { PluginComponentWithAnchor } from '../../../typesClient.js'\nimport type { ToolbarGroup, ToolbarGroupItem } from '../../types.js'\nimport type { FixedToolbarFeatureProps } from '../feature.server.js'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport { ToolbarButton } from '../../shared/ToolbarButton/index.js'\nimport { ToolbarDropdown } from '../../shared/ToolbarDropdown/index.js'\nimport './index.scss'\n\nfunction ButtonGroupItem({\n  anchorElem,\n  editor,\n  item,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  item: ToolbarGroupItem\n}): React.ReactNode {\n  if (item.Component) {\n    return (\n      item?.Component && (\n        <item.Component anchorElem={anchorElem} editor={editor} item={item} key={item.key} />\n      )\n    )\n  }\n\n  return (\n    <ToolbarButton editor={editor} item={item} key={item.key}>\n      {item?.ChildComponent && <item.ChildComponent />}\n    </ToolbarButton>\n  )\n}\n\nfunction ToolbarGroupComponent({\n  anchorElem,\n  editor,\n  editorConfig,\n  group,\n  index,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  editorConfig: SanitizedClientEditorConfig\n  group: ToolbarGroup\n  index: number\n}): React.ReactNode {\n  const { i18n } = useTranslation()\n\n  const [dropdownLabel, setDropdownLabel] = React.useState<null | string>(null)\n  const [DropdownIcon, setDropdownIcon] = React.useState<React.FC | null>(null)\n\n  React.useEffect(() => {\n    if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {\n      setDropdownIcon(() => group.ChildComponent)\n    } else {\n      setDropdownIcon(null)\n    }\n  }, [group])\n\n  const onActiveChange = ({ activeItems }: { activeItems: ToolbarGroupItem[] }) => {\n    if (!activeItems.length) {\n      if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {\n        setDropdownIcon(() => group.ChildComponent)\n        setDropdownLabel(null)\n      } else {\n        setDropdownIcon(null)\n        setDropdownLabel(null)\n      }\n      return\n    }\n    const item = activeItems[0]\n\n    let label = item.key\n    if (item.label) {\n      label = typeof item.label === 'function' ? item.label({ i18n }) : item.label\n    }\n    // Crop title to max. 25 characters\n    if (label.length > 25) {\n      label = label.substring(0, 25) + '...'\n    }\n    setDropdownLabel(label)\n    setDropdownIcon(() => item.ChildComponent)\n  }\n\n  return (\n    <div className={`fixed-toolbar__group fixed-toolbar__group-${group.key}`} key={group.key}>\n      {group.type === 'dropdown' &&\n        group.items.length &&\n        (DropdownIcon ? (\n          <ToolbarDropdown\n            Icon={DropdownIcon}\n            anchorElem={anchorElem}\n            editor={editor}\n            groupKey={group.key}\n            items={group.items}\n            itemsContainerClassNames={['fixed-toolbar__dropdown-items']}\n            label={dropdownLabel}\n            maxActiveItems={1}\n            onActiveChange={onActiveChange}\n          />\n        ) : (\n          <ToolbarDropdown\n            anchorElem={anchorElem}\n            editor={editor}\n            groupKey={group.key}\n            items={group.items}\n            itemsContainerClassNames={['fixed-toolbar__dropdown-items']}\n            label={dropdownLabel}\n            maxActiveItems={1}\n            onActiveChange={onActiveChange}\n          />\n        ))}\n      {group.type === 'buttons' &&\n        group.items.length &&\n        group.items.map((item) => {\n          return (\n            <ButtonGroupItem anchorElem={anchorElem} editor={editor} item={item} key={item.key} />\n          )\n        })}\n      {index < editorConfig.features.toolbarFixed?.groups.length - 1 && <div className=\"divider\" />}\n    </div>\n  )\n}\n\nfunction FixedToolbar({\n  anchorElem,\n  clientProps,\n  editor,\n  editorConfig,\n  parentWithFixedToolbar,\n}: {\n  anchorElem: HTMLElement\n  clientProps?: FixedToolbarFeatureProps\n  editor: LexicalEditor\n  editorConfig: SanitizedClientEditorConfig\n  parentWithFixedToolbar: EditorConfigContextType | false\n}): React.ReactNode {\n  const currentToolbarRef = React.useRef<HTMLDivElement>(null)\n\n  const { y } = useScrollInfo()\n\n  // Memoize the parent toolbar element\n  const parentToolbarElem = useMemo(() => {\n    if (!parentWithFixedToolbar || clientProps?.disableIfParentHasFixedToolbar) {\n      return null\n    }\n\n    const parentEditorElem = parentWithFixedToolbar.editorContainerRef.current\n    let sibling = parentEditorElem.previousElementSibling\n    while (sibling) {\n      if (sibling.classList.contains('fixed-toolbar')) {\n        return sibling\n      }\n      sibling = sibling.previousElementSibling\n    }\n    return null\n  }, [clientProps?.disableIfParentHasFixedToolbar, parentWithFixedToolbar])\n\n  useThrottledEffect(\n    () => {\n      if (!parentToolbarElem) {\n        // this also checks for clientProps?.disableIfParentHasFixedToolbar indirectly, see the parentToolbarElem useMemo\n        return\n      }\n      const currentToolbarElem = currentToolbarRef.current\n      if (!currentToolbarElem) {\n        return\n      }\n\n      const currentRect = currentToolbarElem.getBoundingClientRect()\n      const parentRect = parentToolbarElem.getBoundingClientRect()\n\n      // we only need to check for vertical overlap\n      const overlapping = !(\n        currentRect.bottom < parentRect.top || currentRect.top > parentRect.bottom\n      )\n\n      if (overlapping) {\n        currentToolbarRef.current.className = 'fixed-toolbar fixed-toolbar--overlapping'\n        parentToolbarElem.className = 'fixed-toolbar fixed-toolbar--hide'\n      } else {\n        if (!currentToolbarRef.current.classList.contains('fixed-toolbar--overlapping')) {\n          return\n        }\n        currentToolbarRef.current.className = 'fixed-toolbar'\n        parentToolbarElem.className = 'fixed-toolbar'\n      }\n    },\n    50,\n    [currentToolbarRef, parentToolbarElem, y],\n  )\n\n  return (\n    <div\n      className=\"fixed-toolbar\"\n      onFocus={(event) => {\n        // Prevent other focus events being triggered. Otherwise, if this was to be clicked while in a child editor,\n        // the parent editor will be focused, and the child editor will lose focus.\n        event.stopPropagation()\n      }}\n      ref={currentToolbarRef}\n    >\n      {editor.isEditable() && (\n        <React.Fragment>\n          {editorConfig?.features &&\n            editorConfig.features?.toolbarFixed?.groups.map((group, i) => {\n              return (\n                <ToolbarGroupComponent\n                  anchorElem={anchorElem}\n                  editor={editor}\n                  editorConfig={editorConfig}\n                  group={group}\n                  index={i}\n                  key={group.key}\n                />\n              )\n            })}\n        </React.Fragment>\n      )}\n    </div>\n  )\n}\n\nconst getParentEditorWithFixedToolbar = (\n  editorConfigContext: EditorConfigContextType,\n): EditorConfigContextType | false => {\n  if (editorConfigContext.parentEditor?.editorConfig) {\n    if (editorConfigContext.parentEditor?.editorConfig.resolvedFeatureMap.has('toolbarFixed')) {\n      return editorConfigContext.parentEditor\n    } else {\n      if (editorConfigContext.parentEditor) {\n        return getParentEditorWithFixedToolbar(editorConfigContext.parentEditor)\n      }\n    }\n  }\n  return false\n}\n\nexport const FixedToolbarPlugin: PluginComponentWithAnchor<FixedToolbarFeatureProps> = ({\n  anchorElem,\n  clientProps,\n}) => {\n  const [currentEditor] = useLexicalComposerContext()\n  const editorConfigContext = useEditorConfigContext()\n\n  const { editorConfig: currentEditorConfig } = editorConfigContext\n\n  const editor = clientProps.applyToFocusedEditor\n    ? editorConfigContext.focusedEditor?.editor || currentEditor\n    : currentEditor\n\n  const editorConfig = clientProps.applyToFocusedEditor\n    ? editorConfigContext.focusedEditor?.editorConfig || currentEditorConfig\n    : currentEditorConfig\n\n  const parentWithFixedToolbar = getParentEditorWithFixedToolbar(editorConfigContext)\n\n  if (clientProps?.disableIfParentHasFixedToolbar) {\n    if (parentWithFixedToolbar) {\n      return null\n    }\n  }\n\n  if (!editorConfig?.features?.toolbarFixed?.groups?.length) {\n    return null\n  }\n\n  return (\n    <FixedToolbar\n      anchorElem={anchorElem}\n      editor={editor}\n      editorConfig={editorConfig}\n      parentWithFixedToolbar={parentWithFixedToolbar}\n    />\n  )\n}\n"],"names":["useLexicalComposerContext","useScrollInfo","useThrottledEffect","useTranslation","React","useMemo","useEditorConfigContext","ToolbarButton","ToolbarDropdown","ButtonGroupItem","anchorElem","editor","item","Component","key","ChildComponent","ToolbarGroupComponent","editorConfig","group","index","i18n","dropdownLabel","setDropdownLabel","useState","DropdownIcon","setDropdownIcon","useEffect","type","items","length","onActiveChange","activeItems","label","substring","div","className","Icon","groupKey","itemsContainerClassNames","maxActiveItems","map","features","toolbarFixed","groups","FixedToolbar","clientProps","parentWithFixedToolbar","currentToolbarRef","useRef","y","parentToolbarElem","disableIfParentHasFixedToolbar","parentEditorElem","editorContainerRef","current","sibling","previousElementSibling","classList","contains","currentToolbarElem","currentRect","getBoundingClientRect","parentRect","overlapping","bottom","top","onFocus","event","stopPropagation","ref","isEditable","Fragment","i","getParentEditorWithFixedToolbar","editorConfigContext","parentEditor","resolvedFeatureMap","has","FixedToolbarPlugin","currentEditor","currentEditorConfig","applyToFocusedEditor","focusedEditor"],"mappings":"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"}

package/dist/features/toolbars/fixed/feature.client.d.ts

@@ -1,6 +0,0 @@
-import type { FixedToolbarFeatureProps } from './feature.server.js';
-export declare const FixedToolbarFeatureClient: import("react").FC<{
-    featureKey: string;
-    order: number;
-} & FixedToolbarFeatureProps>;
-//# sourceMappingURL=feature.client.d.ts.map

package/dist/features/toolbars/fixed/feature.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/toolbars/fixed/feature.client.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAKnE,eAAO,MAAM,yBAAyB;;;6BAOpC,CAAA"}

package/dist/features/toolbars/fixed/feature.client.js

@@ -1,13 +0,0 @@
-'use client';
-import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { FixedToolbarPlugin } from './Toolbar/index.js';
-export const FixedToolbarFeatureClient = createClientFeature({
-    plugins: [
-        {
-            Component: FixedToolbarPlugin,
-            position: 'aboveContainer'
-        }
-    ]
-});
-
-//# sourceMappingURL=feature.client.js.map

package/dist/features/toolbars/fixed/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/features/toolbars/fixed/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FixedToolbarFeatureProps } from './feature.server.js'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { FixedToolbarPlugin } from './Toolbar/index.js'\n\nexport const FixedToolbarFeatureClient = createClientFeature<FixedToolbarFeatureProps>({\n  plugins: [\n    {\n      Component: FixedToolbarPlugin,\n      position: 'aboveContainer',\n    },\n  ],\n})\n"],"names":["createClientFeature","FixedToolbarPlugin","FixedToolbarFeatureClient","plugins","Component","position"],"mappings":"AAAA;AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,kBAAkB,QAAQ,qBAAoB;AAEvD,OAAO,MAAMC,4BAA4BF,oBAA8C;IACrFG,SAAS;QACP;YACEC,WAAWH;YACXI,UAAU;QACZ;KACD;AACH,GAAE"}

package/dist/features/toolbars/fixed/feature.server.d.ts

@@ -1,18 +0,0 @@
-export type FixedToolbarFeatureProps = {
-    /**
-     * @default false
-     *
-     * If this is enabled, the toolbar will apply to the focused editor, not the editor with the FixedToolbarFeature.
-     *
-     * This means that if the editor has a child-editor, and the child-editor is focused, the toolbar will apply to the child-editor, not the parent editor with this feature added.
-     */
-    applyToFocusedEditor?: boolean;
-    /**
-     * @default false
-     *
-     * If there is a parent editor with a fixed toolbar, this will disable the toolbar for this editor.
-     */
-    disableIfParentHasFixedToolbar?: boolean;
-};
-export declare const FixedToolbarFeature: import("../../typesServer.js").FeatureProviderProviderServer<FixedToolbarFeatureProps, FixedToolbarFeatureProps, FixedToolbarFeatureProps>;
-//# sourceMappingURL=feature.server.d.ts.map

package/dist/features/toolbars/fixed/feature.server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/toolbars/fixed/feature.server.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,mBAAmB,4IAsB9B,CAAA"}

package/dist/features/toolbars/fixed/feature.server.js

@@ -1,19 +0,0 @@
-// eslint-disable-next-line payload/no-imports-from-exports-dir
-import { FixedToolbarFeatureClient } from '../../../exports/client/index.js';
-import { createServerFeature } from '../../../utilities/createServerFeature.js';
-export const FixedToolbarFeature = createServerFeature({
-    feature: ({ props })=>{
-        const sanitizedProps = {
-            applyToFocusedEditor: props?.applyToFocusedEditor === undefined ? false : props.applyToFocusedEditor,
-            disableIfParentHasFixedToolbar: props?.disableIfParentHasFixedToolbar === undefined ? false : props.disableIfParentHasFixedToolbar
-        };
-        return {
-            ClientFeature: FixedToolbarFeatureClient,
-            clientFeatureProps: sanitizedProps,
-            sanitizedServerFeatureProps: sanitizedProps
-        };
-    },
-    key: 'toolbarFixed'
-});
-
-//# sourceMappingURL=feature.server.js.map

package/dist/features/toolbars/fixed/feature.server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/features/toolbars/fixed/feature.server.ts"],"sourcesContent":["// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { FixedToolbarFeatureClient } from '../../../exports/client/index.js'\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\n\nexport type FixedToolbarFeatureProps = {\n  /**\n   * @default false\n   *\n   * If this is enabled, the toolbar will apply to the focused editor, not the editor with the FixedToolbarFeature.\n   *\n   * This means that if the editor has a child-editor, and the child-editor is focused, the toolbar will apply to the child-editor, not the parent editor with this feature added.\n   */\n  applyToFocusedEditor?: boolean\n  /**\n   * @default false\n   *\n   * If there is a parent editor with a fixed toolbar, this will disable the toolbar for this editor.\n   */\n  disableIfParentHasFixedToolbar?: boolean\n}\n\nexport const FixedToolbarFeature = createServerFeature<\n  FixedToolbarFeatureProps,\n  FixedToolbarFeatureProps,\n  FixedToolbarFeatureProps\n>({\n  feature: ({ props }) => {\n    const sanitizedProps: FixedToolbarFeatureProps = {\n      applyToFocusedEditor:\n        props?.applyToFocusedEditor === undefined ? false : props.applyToFocusedEditor,\n      disableIfParentHasFixedToolbar:\n        props?.disableIfParentHasFixedToolbar === undefined\n          ? false\n          : props.disableIfParentHasFixedToolbar,\n    }\n\n    return {\n      ClientFeature: FixedToolbarFeatureClient,\n      clientFeatureProps: sanitizedProps,\n      sanitizedServerFeatureProps: sanitizedProps,\n    }\n  },\n  key: 'toolbarFixed',\n})\n"],"names":["FixedToolbarFeatureClient","createServerFeature","FixedToolbarFeature","feature","props","sanitizedProps","applyToFocusedEditor","undefined","disableIfParentHasFixedToolbar","ClientFeature","clientFeatureProps","sanitizedServerFeatureProps","key"],"mappings":"AAAA,+DAA+D;AAC/D,SAASA,yBAAyB,QAAQ,mCAAkC;AAC5E,SAASC,mBAAmB,QAAQ,4CAA2C;AAmB/E,OAAO,MAAMC,sBAAsBD,oBAIjC;IACAE,SAAS,CAAC,EAAEC,KAAK,EAAE;QACjB,MAAMC,iBAA2C;YAC/CC,sBACEF,OAAOE,yBAAyBC,YAAY,QAAQH,MAAME,oBAAoB;YAChFE,gCACEJ,OAAOI,mCAAmCD,YACtC,QACAH,MAAMI,8BAA8B;QAC5C;QAEA,OAAO;YACLC,eAAeT;YACfU,oBAAoBL;YACpBM,6BAA6BN;QAC/B;IACF;IACAO,KAAK;AACP,GAAE"}

package/dist/features/toolbars/inline/Toolbar/index.d.ts

@@ -1,4 +0,0 @@
-import type { PluginComponentWithAnchor } from '../../../typesClient.js';
-import './index.scss';
-export declare const InlineToolbarPlugin: PluginComponentWithAnchor<undefined>;
-//# sourceMappingURL=index.d.ts.map

package/dist/features/toolbars/inline/Toolbar/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/toolbars/inline/Toolbar/index.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAQxE,OAAO,cAAc,CAAA;AAqXrB,eAAO,MAAM,mBAAmB,EAAE,yBAAyB,CAAC,SAAS,CAIpE,CAAA"}

package/dist/features/toolbars/inline/Toolbar/index.js

@@ -1,319 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
-import { mergeRegister } from '@lexical/utils';
-import { $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, SELECTION_CHANGE_COMMAND } from 'lexical';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import * as React from 'react';
-import { createPortal } from 'react-dom';
-import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
-import { getDOMRangeRect } from '../../../../lexical/utils/getDOMRangeRect.js';
-import { setFloatingElemPosition } from '../../../../lexical/utils/setFloatingElemPosition.js';
-import { ToolbarButton } from '../../shared/ToolbarButton/index.js';
-import { ToolbarDropdown } from '../../shared/ToolbarDropdown/index.js';
-function ButtonGroupItem({ anchorElem, editor, item }) {
-    if (item.Component) {
-        return item?.Component && /*#__PURE__*/ _jsx(item.Component, {
-            anchorElem: anchorElem,
-            editor: editor,
-            item: item
-        }, item.key);
-    }
-    return /*#__PURE__*/ _jsx(ToolbarButton, {
-        editor: editor,
-        item: item,
-        children: item?.ChildComponent && /*#__PURE__*/ _jsx(item.ChildComponent, {})
-    }, item.key);
-}
-function ToolbarGroupComponent({ anchorElem, editor, group, index }) {
-    const { editorConfig } = useEditorConfigContext();
-    const [DropdownIcon, setDropdownIcon] = React.useState(null);
-    React.useEffect(()=>{
-        if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {
-            setDropdownIcon(()=>group.ChildComponent);
-        } else {
-            setDropdownIcon(null);
-        }
-    }, [
-        group
-    ]);
-    const onActiveChange = ({ activeItems })=>{
-        if (!activeItems.length) {
-            if (group?.type === 'dropdown' && group.items.length && group.ChildComponent) {
-                setDropdownIcon(()=>group.ChildComponent);
-            } else {
-                setDropdownIcon(null);
-            }
-            return;
-        }
-        const item = activeItems[0];
-        setDropdownIcon(()=>item.ChildComponent);
-    };
-    return /*#__PURE__*/ _jsxs("div", {
-        className: `inline-toolbar-popup__group inline-toolbar-popup__group-${group.key}`,
-        children: [
-            group.type === 'dropdown' && group.items.length && (DropdownIcon ? /*#__PURE__*/ _jsx(ToolbarDropdown, {
-                Icon: DropdownIcon,
-                anchorElem: anchorElem,
-                editor: editor,
-                groupKey: group.key,
-                items: group.items,
-                maxActiveItems: 1,
-                onActiveChange: onActiveChange
-            }) : /*#__PURE__*/ _jsx(ToolbarDropdown, {
-                anchorElem: anchorElem,
-                editor: editor,
-                groupKey: group.key,
-                items: group.items,
-                maxActiveItems: 1,
-                onActiveChange: onActiveChange
-            })),
-            group.type === 'buttons' && group.items.length && group.items.map((item)=>{
-                return /*#__PURE__*/ _jsx(ButtonGroupItem, {
-                    anchorElem: anchorElem,
-                    editor: editor,
-                    item: item
-                }, item.key);
-            }),
-            index < editorConfig.features.toolbarInline?.groups.length - 1 && /*#__PURE__*/ _jsx("div", {
-                className: "divider"
-            })
-        ]
-    }, group.key);
-}
-function InlineToolbar({ anchorElem, editor }) {
-    const floatingToolbarRef = useRef(null);
-    const caretRef = useRef(null);
-    const { editorConfig } = useEditorConfigContext();
-    const closeFloatingToolbar = useCallback(()=>{
-        if (floatingToolbarRef?.current) {
-            const isOpacityZero = floatingToolbarRef.current.style.opacity === '0';
-            const isPointerEventsNone = floatingToolbarRef.current.style.pointerEvents === 'none';
-            if (!isOpacityZero) {
-                floatingToolbarRef.current.style.opacity = '0';
-            }
-            if (!isPointerEventsNone) {
-                floatingToolbarRef.current.style.pointerEvents = 'none';
-            }
-        }
-    }, [
-        floatingToolbarRef
-    ]);
-    const mouseMoveListener = useCallback((e)=>{
-        if (floatingToolbarRef?.current && (e.buttons === 1 || e.buttons === 3)) {
-            const isOpacityZero = floatingToolbarRef.current.style.opacity === '0';
-            const isPointerEventsNone = floatingToolbarRef.current.style.pointerEvents === 'none';
-            if (!isOpacityZero || !isPointerEventsNone) {
-                // Check if the mouse is not over the popup
-                const x = e.clientX;
-                const y = e.clientY;
-                const elementUnderMouse = document.elementFromPoint(x, y);
-                if (!floatingToolbarRef.current.contains(elementUnderMouse)) {
-                    // Mouse is not over the target element => not a normal click, but probably a drag
-                    closeFloatingToolbar();
-                }
-            }
-        }
-    }, [
-        closeFloatingToolbar
-    ]);
-    const mouseUpListener = useCallback(()=>{
-        if (floatingToolbarRef?.current) {
-            if (floatingToolbarRef.current.style.opacity !== '1') {
-                floatingToolbarRef.current.style.opacity = '1';
-            }
-            if (floatingToolbarRef.current.style.pointerEvents !== 'auto') {
-                floatingToolbarRef.current.style.pointerEvents = 'auto';
-            }
-        }
-    }, []);
-    useEffect(()=>{
-        document.addEventListener('mousemove', mouseMoveListener);
-        document.addEventListener('mouseup', mouseUpListener);
-        return ()=>{
-            document.removeEventListener('mousemove', mouseMoveListener);
-            document.removeEventListener('mouseup', mouseUpListener);
-        };
-    }, [
-        floatingToolbarRef,
-        mouseMoveListener,
-        mouseUpListener
-    ]);
-    const $updateTextFormatFloatingToolbar = useCallback(()=>{
-        const selection = $getSelection();
-        const nativeSelection = window.getSelection();
-        if (floatingToolbarRef.current === null) {
-            return;
-        }
-        const possibleLinkEditor = anchorElem.querySelector(':scope > .link-editor');
-        const isLinkEditorVisible = possibleLinkEditor !== null && 'style' in possibleLinkEditor && possibleLinkEditor?.style?.['opacity'] === '1';
-        const rootElement = editor.getRootElement();
-        if (selection !== null && nativeSelection !== null && !nativeSelection.isCollapsed && rootElement !== null && rootElement.contains(nativeSelection.anchorNode)) {
-            const rangeRect = getDOMRangeRect(nativeSelection, rootElement);
-            // Position floating toolbar
-            const offsetIfFlipped = setFloatingElemPosition({
-                alwaysDisplayOnTop: isLinkEditorVisible,
-                anchorElem,
-                floatingElem: floatingToolbarRef.current,
-                horizontalPosition: 'center',
-                targetRect: rangeRect
-            });
-            // Position caret
-            if (caretRef.current) {
-                setFloatingElemPosition({
-                    anchorElem: floatingToolbarRef.current,
-                    anchorFlippedOffset: offsetIfFlipped,
-                    floatingElem: caretRef.current,
-                    horizontalOffset: 5,
-                    horizontalPosition: 'center',
-                    specialHandlingForCaret: true,
-                    targetRect: rangeRect,
-                    verticalGap: 10
-                });
-            }
-        } else {
-            closeFloatingToolbar();
-        }
-    }, [
-        editor,
-        closeFloatingToolbar,
-        anchorElem
-    ]);
-    useEffect(()=>{
-        const scrollerElem = anchorElem.parentElement;
-        const update = ()=>{
-            editor.getEditorState().read(()=>{
-                $updateTextFormatFloatingToolbar();
-            });
-        };
-        window.addEventListener('resize', update);
-        if (scrollerElem) {
-            scrollerElem.addEventListener('scroll', update);
-        }
-        return ()=>{
-            window.removeEventListener('resize', update);
-            if (scrollerElem) {
-                scrollerElem.removeEventListener('scroll', update);
-            }
-        };
-    }, [
-        editor,
-        $updateTextFormatFloatingToolbar,
-        anchorElem
-    ]);
-    useEffect(()=>{
-        editor.getEditorState().read(()=>{
-            $updateTextFormatFloatingToolbar();
-        });
-        return mergeRegister(editor.registerUpdateListener(({ editorState })=>{
-            editorState.read(()=>{
-                $updateTextFormatFloatingToolbar();
-            });
-        }), editor.registerCommand(SELECTION_CHANGE_COMMAND, ()=>{
-            $updateTextFormatFloatingToolbar();
-            return false;
-        }, COMMAND_PRIORITY_LOW));
-    }, [
-        editor,
-        $updateTextFormatFloatingToolbar
-    ]);
-    return /*#__PURE__*/ _jsxs("div", {
-        className: "inline-toolbar-popup",
-        ref: floatingToolbarRef,
-        children: [
-            /*#__PURE__*/ _jsx("div", {
-                className: "caret",
-                ref: caretRef
-            }),
-            editor.isEditable() && /*#__PURE__*/ _jsx(React.Fragment, {
-                children: editorConfig?.features && editorConfig.features?.toolbarInline?.groups.map((group, i)=>{
-                    return /*#__PURE__*/ _jsx(ToolbarGroupComponent, {
-                        anchorElem: anchorElem,
-                        editor: editor,
-                        group: group,
-                        index: i
-                    }, group.key);
-                })
-            })
-        ]
-    });
-}
-function useInlineToolbar(editor, anchorElem) {
-    const [isText, setIsText] = useState(false);
-    const updatePopup = useCallback(()=>{
-        editor.getEditorState().read(()=>{
-            // Should not to pop up the floating toolbar when using IME input
-            if (editor.isComposing()) {
-                return;
-            }
-            const selection = $getSelection();
-            const nativeSelection = window.getSelection();
-            const rootElement = editor.getRootElement();
-            if (nativeSelection !== null && (!$isRangeSelection(selection) || rootElement === null || !rootElement.contains(nativeSelection.anchorNode))) {
-                setIsText(false);
-                return;
-            }
-            if (!$isRangeSelection(selection)) {
-                return;
-            }
-            if (selection.getTextContent() !== '') {
-                const nodes = selection.getNodes();
-                let foundNodeWithText = false;
-                for (const node of nodes){
-                    if ($isTextNode(node)) {
-                        setIsText(true);
-                        foundNodeWithText = true;
-                        break;
-                    }
-                }
-                if (!foundNodeWithText) {
-                    setIsText(false);
-                }
-            } else {
-                setIsText(false);
-            }
-            const rawTextContent = selection.getTextContent().replace(/\n/g, '');
-            if (!selection.isCollapsed() && rawTextContent === '') {
-                setIsText(false);
-                return;
-            }
-        });
-    }, [
-        editor
-    ]);
-    useEffect(()=>{
-        document.addEventListener('selectionchange', updatePopup);
-        document.addEventListener('mouseup', updatePopup);
-        return ()=>{
-            document.removeEventListener('selectionchange', updatePopup);
-            document.removeEventListener('mouseup', updatePopup);
-        };
-    }, [
-        updatePopup
-    ]);
-    useEffect(()=>{
-        return mergeRegister(editor.registerUpdateListener(()=>{
-            updatePopup();
-        }), editor.registerRootListener(()=>{
-            if (editor.getRootElement() === null) {
-                setIsText(false);
-            }
-        }));
-    }, [
-        editor,
-        updatePopup
-    ]);
-    if (!isText) {
-        return null;
-    }
-    return /*#__PURE__*/ createPortal(/*#__PURE__*/ _jsx(InlineToolbar, {
-        anchorElem: anchorElem,
-        editor: editor
-    }), anchorElem);
-}
-export const InlineToolbarPlugin = ({ anchorElem })=>{
-    const [editor] = useLexicalComposerContext();
-    return useInlineToolbar(editor, anchorElem);
-};
-
-//# sourceMappingURL=index.js.map