@payloadcms/richtext-lexical 3.0.0-beta.24 → 3.0.0-beta.26

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

@@ -0,0 +1,152 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { useTranslation } from '@payloadcms/ui/providers/Translation';
+import * as React from 'react';
+import { useEditorFocus } from '../../../../lexical/EditorFocusProvider.js';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
+import { ToolbarButton } from '../../shared/ToolbarButton/index.js';
+import { ToolbarDropdown } from '../../shared/ToolbarDropdown/index.js';
+import './index.scss';
+function ButtonGroupItem({ anchorElem, editor, item }) {
+    if (item.Component) {
+        return item?.Component && /*#__PURE__*/ React.createElement(item.Component, {
+            anchorElem: anchorElem,
+            editor: editor,
+            item: item,
+            key: item.key
+        });
+    }
+    return /*#__PURE__*/ React.createElement(ToolbarButton, {
+        editor: editor,
+        item: item,
+        key: item.key
+    }, item?.ChildComponent && /*#__PURE__*/ React.createElement(item.ChildComponent, null));
+}
+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__*/ React.createElement("div", {
+        className: `fixed-toolbar__group fixed-toolbar__group-${group.key}`,
+        key: group.key
+    }, group.type === 'dropdown' && group.items.length && (DropdownIcon ? /*#__PURE__*/ React.createElement(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__*/ React.createElement(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__*/ React.createElement(ButtonGroupItem, {
+            anchorElem: anchorElem,
+            editor: editor,
+            item: item,
+            key: item.key
+        });
+    }), index < editorConfig.features.toolbarFixed?.groups.length - 1 && /*#__PURE__*/ React.createElement("div", {
+        className: "divider"
+    }));
+}
+function FixedToolbar({ anchorElem, editor, editorConfig }) {
+    return /*#__PURE__*/ React.createElement("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();
+        }
+    }, editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, editorConfig?.features && editorConfig.features?.toolbarFixed?.groups.map((group, i)=>{
+        return /*#__PURE__*/ React.createElement(ToolbarGroupComponent, {
+            anchorElem: anchorElem,
+            editor: editor,
+            editorConfig: editorConfig,
+            group: group,
+            index: i,
+            key: group.key
+        });
+    })));
+}
+const checkParentEditor = (editorFocus)=>{
+    if (editorFocus.parentEditorConfigContext?.editorConfig) {
+        if (editorFocus.parentEditorConfigContext?.editorConfig.resolvedFeatureMap.has('toolbarFixed')) {
+            return true;
+        } else {
+            if (editorFocus.parentEditorFocus) {
+                return checkParentEditor(editorFocus.parentEditorFocus);
+            }
+        }
+    }
+    return false;
+};
+export const FixedToolbarPlugin = ({ anchorElem })=>{
+    const [currentEditor] = useLexicalComposerContext();
+    const { editorConfig: currentEditorConfig, uuid } = useEditorConfigContext();
+    const editorFocus = useEditorFocus();
+    const editor = editorFocus.focusedEditor || currentEditor;
+    const editorConfig = editorFocus.focusedEditorConfigContext?.editorConfig || currentEditorConfig;
+    // Check if there is a parent editor with a fixed toolbar already
+    const hasParentWithFixedToolbar = checkParentEditor(editorFocus);
+    if (hasParentWithFixedToolbar) {
+        return null;
+    }
+    if (!editorConfig?.features?.toolbarFixed?.groups?.length) {
+        return null;
+    }
+    return /*#__PURE__*/ React.createElement(FixedToolbar, {
+        anchorElem: anchorElem,
+        editor: editor,
+        editorConfig: editorConfig
+    });
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/field/features/toolbars/fixed/Toolbar/index.tsx"],"sourcesContent":["'use client'\nimport type { LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { useTranslation } from '@payloadcms/ui/providers/Translation'\nimport * as React from 'react'\n\nimport type { EditorFocusContextType } from '../../../../lexical/EditorFocusProvider.js'\nimport type { SanitizedClientEditorConfig } from '../../../../lexical/config/types.js'\nimport type { PluginComponentWithAnchor } from '../../../types.js'\nimport type { ToolbarGroup, ToolbarGroupItem } from '../../types.js'\n\nimport { useEditorFocus } from '../../../../lexical/EditorFocusProvider.js'\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  editor,\n  editorConfig,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  editorConfig: SanitizedClientEditorConfig\n}): React.ReactNode {\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    >\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 checkParentEditor = (editorFocus: EditorFocusContextType): boolean => {\n  if (editorFocus.parentEditorConfigContext?.editorConfig) {\n    if (\n      editorFocus.parentEditorConfigContext?.editorConfig.resolvedFeatureMap.has('toolbarFixed')\n    ) {\n      return true\n    } else {\n      if (editorFocus.parentEditorFocus) {\n        return checkParentEditor(editorFocus.parentEditorFocus)\n      }\n    }\n  }\n  return false\n}\n\nexport const FixedToolbarPlugin: PluginComponentWithAnchor<undefined> = ({ anchorElem }) => {\n  const [currentEditor] = useLexicalComposerContext()\n  const { editorConfig: currentEditorConfig, uuid } = useEditorConfigContext()\n\n  const editorFocus = useEditorFocus()\n  const editor = editorFocus.focusedEditor || currentEditor\n\n  const editorConfig = editorFocus.focusedEditorConfigContext?.editorConfig || currentEditorConfig\n\n  // Check if there is a parent editor with a fixed toolbar already\n  const hasParentWithFixedToolbar = checkParentEditor(editorFocus)\n\n  if (hasParentWithFixedToolbar) {\n    return null\n  }\n\n  if (!editorConfig?.features?.toolbarFixed?.groups?.length) {\n    return null\n  }\n\n  return <FixedToolbar anchorElem={anchorElem} editor={editor} editorConfig={editorConfig} />\n}\n"],"names":["useLexicalComposerContext","useTranslation","React","useEditorFocus","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","onFocus","event","stopPropagation","isEditable","Fragment","i","checkParentEditor","editorFocus","parentEditorConfigContext","resolvedFeatureMap","has","parentEditorFocus","FixedToolbarPlugin","currentEditor","currentEditorConfig","uuid","focusedEditor","focusedEditorConfigContext","hasParentWithFixedToolbar"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/features/toolbars/fixed/Toolbar/index.scss

@@ -0,0 +1,81 @@
+@import '../../../../../scss/styles';
+
+
+html[data-theme='dark'] {
+  .fixed-toolbar {
+    &__dropdown-items {
+      background: var(--theme-elevation-0);
+
+      .toolbar-popup__dropdown-item {
+        color: var(--theme-elevation-900);
+
+        &:hover:not([disabled]), &.active {
+          background-color: var(--theme-elevation-100);
+        }
+
+        .icon {
+          color: var(--theme-elevation-600);
+        }
+      }
+    }
+
+    .toolbar-popup {
+      &__button {
+        &.active, &:hover:not([disabled]) {
+          background-color: var(--theme-elevation-100);
+        }
+      }
+
+      &__dropdown {
+        &:hover:not([disabled]) {
+          background-color: var(--theme-elevation-100);
+        }
+
+        &-caret:after {
+          filter: invert(1);
+        }
+
+        &-label {
+          color: var(--theme-elevation-750);
+        }
+      }
+    }
+  }
+}
+
+
+.fixed-toolbar {
+  @include blur-bg(var(--theme-elevation-0));
+  display: flex;
+  flex-wrap: wrap;
+  align-items: stretch;
+  padding: 0 3.72px 0 6.25px;
+  vertical-align: middle;
+  position: sticky;
+  z-index: 2;
+  top: var(--doc-controls-height);
+  margin-bottom: $baseline;
+  border: $style-stroke-width-s solid var(--theme-elevation-150);
+
+
+  &__group {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    z-index: 1;
+
+    .icon {
+      min-width: 20px;
+      height: 20px;
+      color: var(--theme-elevation-600);
+    }
+
+    .divider {
+      width: 1px;
+      height: 15px;
+      background-color: var(--color-base-100);
+      margin: 0 6.25px;
+    }
+  }
+
+}

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

@@ -0,0 +1,3 @@
+/// <reference types="react" resolution-mode="require"/>
+export declare const FixedToolbarFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/toolbars/fixed/feature.client.tsx"],"names":[],"mappings":";AAsBA,eAAO,MAAM,kCAAkC,+BAAmD,CAAA"}

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

@@ -0,0 +1,20 @@
+'use client';
+import { createClientComponent } from '../../createClientComponent.js';
+import { FixedToolbarPlugin } from './Toolbar/index.js';
+const FixedToolbarFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                plugins: [
+                    {
+                        Component: FixedToolbarPlugin,
+                        position: 'top'
+                    }
+                ]
+            })
+    };
+};
+export const FixedToolbarFeatureClientComponent = createClientComponent(FixedToolbarFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/toolbars/fixed/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { FixedToolbarPlugin } from './Toolbar/index.js'\n\nconst FixedToolbarFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      plugins: [\n        {\n          Component: FixedToolbarPlugin,\n          position: 'top',\n        },\n      ],\n    }),\n  }\n}\n\nexport const FixedToolbarFeatureClientComponent = createClientComponent(FixedToolbarFeatureClient)\n"],"names":["createClientComponent","FixedToolbarPlugin","FixedToolbarFeatureClient","props","clientFeatureProps","feature","plugins","Component","position","FixedToolbarFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,kBAAkB,QAAQ,qBAAoB;AAEvD,MAAMC,4BAAsE,CAACC;IAC3E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,SAAS;oBACP;wBACEC,WAAWN;wBACXO,UAAU;oBACZ;iBACD;YACH,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,qCAAqCT,sBAAsBE,2BAA0B"}

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

@@ -0,0 +1,3 @@
+import type { FeatureProviderProviderServer } from '../../types.js';
+export declare const FixedToolbarFeature: FeatureProviderProviderServer<undefined, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/toolbars/fixed/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAInE,eAAO,MAAM,mBAAmB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CAYnF,CAAA"}

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

@@ -0,0 +1,16 @@
+import { FixedToolbarFeatureClientComponent } from './feature.client.js';
+export const FixedToolbarFeature = (props)=>{
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: FixedToolbarFeatureClientComponent,
+                clientFeatureProps: null,
+                serverFeatureProps: props
+            };
+        },
+        key: 'toolbarFixed',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=feature.server.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/toolbars/fixed/feature.server.ts"],"sourcesContent":["import type { FeatureProviderProviderServer } from '../../types.js'\n\nimport { FixedToolbarFeatureClientComponent } from './feature.client.js'\n\nexport const FixedToolbarFeature: FeatureProviderProviderServer<undefined, undefined> = (props) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: FixedToolbarFeatureClientComponent,\n        clientFeatureProps: null,\n        serverFeatureProps: props,\n      }\n    },\n    key: 'toolbarFixed',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["FixedToolbarFeatureClientComponent","FixedToolbarFeature","props","feature","ClientComponent","clientFeatureProps","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,kCAAkC,QAAQ,sBAAqB;AAExE,OAAO,MAAMC,sBAA2E,CAACC;IACvF,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBJ;gBACjBK,oBAAoB;gBACpBC,oBAAoBJ;YACtB;QACF;QACAK,KAAK;QACLD,oBAAoBJ;IACtB;AACF,EAAC"}

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

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

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

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

package/dist/field/{lexical/plugins → features}/toolbars/inline/Toolbar/index.js

@@ -5,11 +5,11 @@ import { $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, SE
 import { useCallback, useEffect, useRef, useState } from 'react';
 import * as React from 'react';
 import { createPortal } from 'react-dom';
-import { useEditorConfigContext } from '../../../../config/client/EditorConfigProvider.js';
-import { getDOMRangeRect } from '../../../../utils/getDOMRangeRect.js';
-import { setFloatingElemPosition } from '../../../../utils/setFloatingElemPosition.js';
-import { ToolbarButton } from '../ToolbarButton/index.js';
-import { ToolbarDropdown } from '../ToolbarDropdown/index.js';
+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';
 import './index.scss';
 function ButtonGroupItem({ anchorElem, editor, item }) {
     if (item.Component) {
@@ -21,27 +21,53 @@ function ButtonGroupItem({ anchorElem, editor, item }) {
         });
     }
     return /*#__PURE__*/ React.createElement(ToolbarButton, {
+        editor: editor,
         item: item,
         key: item.key
     }, item?.ChildComponent && /*#__PURE__*/ React.createElement(item.ChildComponent, null));
 }
-function ToolbarGroup({ anchorElem, editor, group, index }) {
+function ToolbarGroupComponent({ anchorElem, editor, group, index }) {
     const { editorConfig } = useEditorConfigContext();
-    const Icon = group?.type === 'dropdown' && group.items.length && group.ChildComponent ? group.ChildComponent : 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);
+            } else {
+                setDropdownIcon(null);
+            }
+            return;
+        }
+        const item = activeItems[0];
+        setDropdownIcon(()=>item.ChildComponent);
+    };
     return /*#__PURE__*/ React.createElement("div", {
         className: `inline-toolbar-popup__group inline-toolbar-popup__group-${group.key}`,
         key: group.key
-    }, group.type === 'dropdown' && group.items.length && (Icon ? /*#__PURE__*/ React.createElement(ToolbarDropdown, {
-        Icon: Icon,
+    }, group.type === 'dropdown' && group.items.length && (DropdownIcon ? /*#__PURE__*/ React.createElement(ToolbarDropdown, {
+        Icon: DropdownIcon,
         anchorElem: anchorElem,
         editor: editor,
         groupKey: group.key,
-        items: group.items
+        items: group.items,
+        maxActiveItems: 1,
+        onActiveChange: onActiveChange
     }) : /*#__PURE__*/ React.createElement(ToolbarDropdown, {
         anchorElem: anchorElem,
         editor: editor,
         groupKey: group.key,
-        items: group.items
+        items: group.items,
+        maxActiveItems: 1,
+        onActiveChange: onActiveChange
     })), group.type === 'buttons' && group.items.length && group.items.map((item)=>{
         return /*#__PURE__*/ React.createElement(ButtonGroupItem, {
             anchorElem: anchorElem,
@@ -53,7 +79,7 @@ function ToolbarGroup({ anchorElem, editor, group, index }) {
         className: "divider"
     }));
 }
-function FloatingSelectToolbar({ anchorElem, editor }) {
+function InlineToolbar({ anchorElem, editor }) {
     const floatingToolbarRef = useRef(null);
     const caretRef = useRef(null);
     const { editorConfig } = useEditorConfigContext();
@@ -98,9 +124,7 @@ function FloatingSelectToolbar({ anchorElem, editor }) {
                 floatingToolbarRef.current.style.pointerEvents = 'auto';
             }
         }
-    }, [
-        floatingToolbarRef
-    ]);
+    }, []);
     useEffect(()=>{
         document.addEventListener('mousemove', mouseMoveListener);
         document.addEventListener('mouseup', mouseUpListener);
@@ -119,18 +143,38 @@ function FloatingSelectToolbar({ anchorElem, editor }) {
         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(rangeRect, floatingToolbarRef.current, anchorElem, 'center');
+            const offsetIfFlipped = setFloatingElemPosition({
+                alwaysDisplayOnTop: isLinkEditorVisible,
+                anchorElem,
+                floatingElem: floatingToolbarRef.current,
+                horizontalPosition: 'center',
+                targetRect: rangeRect
+            });
             // Position caret
             if (caretRef.current) {
-                setFloatingElemPosition(rangeRect, caretRef.current, floatingToolbarRef.current, 'center', 10, 5, true, offsetIfFlipped);
+                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(()=>{
@@ -178,7 +222,7 @@ function FloatingSelectToolbar({ anchorElem, editor }) {
         className: "caret",
         ref: caretRef
     }), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, editorConfig?.features && editorConfig.features?.toolbarInline?.groups.map((group, i)=>{
-        return /*#__PURE__*/ React.createElement(ToolbarGroup, {
+        return /*#__PURE__*/ React.createElement(ToolbarGroupComponent, {
             anchorElem: anchorElem,
             editor: editor,
             group: group,
@@ -187,7 +231,7 @@ function FloatingSelectToolbar({ anchorElem, editor }) {
         });
     })));
 }
-function useFloatingTextFormatToolbar(editor, anchorElem) {
+function useInlineToolbar(editor, anchorElem) {
     const [isText, setIsText] = useState(false);
     const updatePopup = useCallback(()=>{
         editor.getEditorState().read(()=>{
@@ -255,14 +299,14 @@ function useFloatingTextFormatToolbar(editor, anchorElem) {
     if (!isText) {
         return null;
     }
-    return /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(FloatingSelectToolbar, {
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(InlineToolbar, {
         anchorElem: anchorElem,
         editor: editor
     }), anchorElem);
 }
-export function FloatingSelectToolbarPlugin({ anchorElem = document.body }) {
+export const InlineToolbarPlugin = ({ anchorElem })=>{
     const [editor] = useLexicalComposerContext();
-    return useFloatingTextFormatToolbar(editor, anchorElem);
-}
+    return useInlineToolbar(editor, anchorElem);
+};
 
 //# sourceMappingURL=index.js.map

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

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

package/dist/field/{lexical/plugins → features}/toolbars/inline/Toolbar/index.scss

@@ -1,4 +1,4 @@
-@import '../../../../../../scss/styles';
+@import '../../../../../scss/styles';
 
 html[data-theme='light'] {
   .inline-toolbar-popup {
@@ -10,12 +10,12 @@ html[data-theme='light'] {
   display: flex;
   align-items: center;
   background: var(--color-base-0);
-  padding: 0px 3.72px 0px 6.25px;
+  padding: 0 3.72px 0 6.25px;
   vertical-align: middle;
   position: absolute;
   top: 0;
   left: 0;
-  z-index: 10;
+  z-index: 2;
   opacity: 0;
   border-radius: 6.25px;
   transition: opacity 0.2s;
@@ -50,9 +50,4 @@ html[data-theme='light'] {
     }
   }
 
-  @media (max-width: 1024px) {
-    button.insert-comment {
-      display: none;
-    }
-  }
 }

package/dist/field/features/toolbars/inline/feature.client.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" resolution-mode="require"/>
+export declare const InlineToolbarFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/toolbars/inline/feature.client.d.ts.map

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

package/dist/field/features/toolbars/inline/feature.client.js

@@ -0,0 +1,20 @@
+'use client';
+import { createClientComponent } from '../../createClientComponent.js';
+import { InlineToolbarPlugin } from './Toolbar/index.js';
+const InlineToolbarFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>({
+                clientFeatureProps: props,
+                plugins: [
+                    {
+                        Component: InlineToolbarPlugin,
+                        position: 'floatingAnchorElem'
+                    }
+                ]
+            })
+    };
+};
+export const InlineToolbarFeatureClientComponent = createClientComponent(InlineToolbarFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/toolbars/inline/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/toolbars/inline/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { InlineToolbarPlugin } from './Toolbar/index.js'\n\nconst InlineToolbarFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      plugins: [\n        {\n          Component: InlineToolbarPlugin,\n          position: 'floatingAnchorElem',\n        },\n      ],\n    }),\n  }\n}\n\nexport const InlineToolbarFeatureClientComponent = createClientComponent(InlineToolbarFeatureClient)\n"],"names":["createClientComponent","InlineToolbarPlugin","InlineToolbarFeatureClient","props","clientFeatureProps","feature","plugins","Component","position","InlineToolbarFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,mBAAmB,QAAQ,qBAAoB;AAExD,MAAMC,6BAAuE,CAACC;IAC5E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,SAAS;oBACP;wBACEC,WAAWN;wBACXO,UAAU;oBACZ;iBACD;YACH,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,sCAAsCT,sBAAsBE,4BAA2B"}

package/dist/field/features/toolbars/inline/feature.server.d.ts

@@ -0,0 +1,3 @@
+import type { FeatureProviderProviderServer } from '../../types.js';
+export declare const InlineToolbarFeature: FeatureProviderProviderServer<undefined, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/toolbars/inline/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/toolbars/inline/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAInE,eAAO,MAAM,oBAAoB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CAcpF,CAAA"}