@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/lexical/config/types.d.ts

@@ -0,0 +1,12 @@
+import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor';
+import type { FeatureProvider, ResolvedFeatureMap, SanitizedFeatures } from '../../features/types';
+export type EditorConfig = {
+    features: FeatureProvider[];
+    lexical: LexicalEditorConfig;
+};
+export type SanitizedEditorConfig = {
+    features: SanitizedFeatures;
+    lexical: LexicalEditorConfig;
+    resolvedFeatureMap: ResolvedFeatureMap;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/field/lexical/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAElG,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,OAAO,EAAE,mBAAmB,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kBAAkB,EAAE,kBAAkB,CAAA;CACvC,CAAA"}

package/dist/field/lexical/config/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/field/lexical/nodes/index.d.ts

@@ -0,0 +1,6 @@
+import type { Klass, LexicalNode } from 'lexical';
+import type { SanitizedEditorConfig } from '../config/types';
+export declare function getEnabledNodes({ editorConfig, }: {
+    editorConfig: SanitizedEditorConfig;
+}): Array<Klass<LexicalNode>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/lexical/nodes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/lexical/nodes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAEjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAE5D,wBAAgB,eAAe,CAAC,EAC9B,YAAY,GACb,EAAE;IACD,YAAY,EAAE,qBAAqB,CAAA;CACpC,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAE5B"}

package/dist/field/lexical/nodes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getEnabledNodes", {
+    enumerable: true,
+    get: function() {
+        return getEnabledNodes;
+    }
+});
+function getEnabledNodes({ editorConfig }) {
+    return editorConfig.features.nodes.map((node)=>node.node);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL25vZGVzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgS2xhc3MsIExleGljYWxOb2RlIH0gZnJvbSAnbGV4aWNhbCdcblxuaW1wb3J0IHR5cGUgeyBTYW5pdGl6ZWRFZGl0b3JDb25maWcgfSBmcm9tICcuLi9jb25maWcvdHlwZXMnXG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRFbmFibGVkTm9kZXMoe1xuICBlZGl0b3JDb25maWcsXG59OiB7XG4gIGVkaXRvckNvbmZpZzogU2FuaXRpemVkRWRpdG9yQ29uZmlnXG59KTogQXJyYXk8S2xhc3M8TGV4aWNhbE5vZGU+PiB7XG4gIHJldHVybiBlZGl0b3JDb25maWcuZmVhdHVyZXMubm9kZXMubWFwKChub2RlKSA9PiBub2RlLm5vZGUpXG59XG4iXSwibmFtZXMiOlsiZ2V0RW5hYmxlZE5vZGVzIiwiZWRpdG9yQ29uZmlnIiwiZmVhdHVyZXMiLCJub2RlcyIsIm1hcCIsIm5vZGUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWdCQTs7O2VBQUFBOzs7QUFBVCxTQUFTQSxnQkFBZ0IsRUFDOUJDLFlBQVksRUFHYjtJQUNDLE9BQU9BLGFBQWFDLFFBQVEsQ0FBQ0MsS0FBSyxDQUFDQyxHQUFHLENBQUMsQ0FBQ0MsT0FBU0EsS0FBS0EsSUFBSTtBQUM1RCJ9

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarButton/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAO/D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA;AAE3D,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,aAAa;cAId,SAAS,QAAQ;WACpB,2BAA2B;uBAoEnC,CAAA"}

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarButton;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'floating-select-toolbar-popup__button';
+const ToolbarButton = ({ children, entry })=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [enabled, setEnabled] = (0, _react.useState)(true);
+    const [active, setActive] = (0, _react.useState)(false);
+    const [className, setClassName] = (0, _react.useState)(baseClass);
+    const updateStates = (0, _react.useCallback)(()=>{
+        editor.getEditorState().read(()=>{
+            const selection = (0, _lexical.$getSelection)();
+            if (entry.isActive) {
+                const isActive = entry.isActive({
+                    editor,
+                    selection
+                });
+                if (active !== isActive) {
+                    setActive(isActive);
+                }
+            }
+            if (entry.isEnabled) {
+                const isEnabled = entry.isEnabled({
+                    editor,
+                    selection
+                });
+                if (enabled !== isEnabled) {
+                    setEnabled(isEnabled);
+                }
+            }
+        });
+    }, [
+        active,
+        editor,
+        enabled,
+        entry
+    ]);
+    (0, _react.useEffect)(()=>{
+        updateStates();
+    }, [
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        document.addEventListener('mouseup', updateStates);
+        return ()=>{
+            document.removeEventListener('mouseup', updateStates);
+        };
+    }, [
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(()=>{
+            updateStates();
+        }));
+    }, [
+        editor,
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        setClassName([
+            baseClass,
+            enabled === false ? 'disabled' : '',
+            active ? 'active' : ''
+        ].filter(Boolean).join(' '));
+    }, [
+        enabled,
+        active,
+        className
+    ]);
+    return /*#__PURE__*/ _react.default.createElement("button", {
+        className: className,
+        onClick: ()=>{
+            if (enabled !== false) {
+                entry.onClick({
+                    editor,
+                    isActive: active
+                });
+            }
+        },
+        type: "button"
+    }, children);
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import * as React from 'react';
+import type { FloatingToolbarSectionEntry } from '../types';
+export declare function DropDownItem({ children, entry, title, }: {
+    children: React.ReactNode;
+    entry: FloatingToolbarSectionEntry;
+    title?: string;
+}): JSX.Element;
+export declare function DropDown({ Icon, buttonAriaLabel, buttonClassName, children, disabled, stopCloseOnClickSelf, }: {
+    Icon?: React.FC;
+    buttonAriaLabel?: string;
+    buttonClassName: string;
+    children: ReactNode;
+    disabled?: boolean;
+    stopCloseOnClickSelf?: boolean;
+}): JSX.Element;
+//# sourceMappingURL=DropDown.d.ts.map

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

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

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

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DropDownItem: function() {
+        return DropDownItem;
+    },
+    DropDown: function() {
+        return DropDown;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const DropDownContext = /*#__PURE__*/ _react.createContext(null);
+function DropDownItem({ children, entry, title }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [enabled, setEnabled] = (0, _react.useState)(true);
+    const [active, setActive] = (0, _react.useState)(false);
+    const [className, setClassName] = (0, _react.useState)('item');
+    const updateStates = (0, _react.useCallback)(()=>{
+        editor.getEditorState().read(()=>{
+            const selection = (0, _lexical.$getSelection)();
+            if (entry.isActive) {
+                const isActive = entry.isActive({
+                    editor,
+                    selection
+                });
+                if (active !== isActive) {
+                    setActive(isActive);
+                }
+            }
+            if (entry.isEnabled) {
+                const isEnabled = entry.isEnabled({
+                    editor,
+                    selection
+                });
+                if (enabled !== isEnabled) {
+                    setEnabled(isEnabled);
+                }
+            }
+        });
+    }, [
+        active,
+        editor,
+        enabled,
+        entry
+    ]);
+    (0, _react.useEffect)(()=>{
+        updateStates();
+    }, [
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        document.addEventListener('mouseup', updateStates);
+        return ()=>{
+            document.removeEventListener('mouseup', updateStates);
+        };
+    }, [
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(()=>{
+            updateStates();
+        }));
+    }, [
+        editor,
+        updateStates
+    ]);
+    (0, _react.useEffect)(()=>{
+        setClassName([
+            'item',
+            enabled === false ? 'disabled' : '',
+            active ? 'active' : ''
+        ].filter(Boolean).join(' '));
+    }, [
+        enabled,
+        active,
+        className
+    ]);
+    const ref = (0, _react.useRef)(null);
+    const dropDownContext = _react.useContext(DropDownContext);
+    if (dropDownContext === null) {
+        throw new Error('DropDownItem must be used within a DropDown');
+    }
+    const { registerItem } = dropDownContext;
+    (0, _react.useEffect)(()=>{
+        if (ref?.current != null) {
+            registerItem(ref);
+        }
+    }, [
+        ref,
+        registerItem
+    ]);
+    return /*#__PURE__*/ _react.createElement("button", {
+        className: className,
+        onClick: ()=>{
+            if (enabled !== false) {
+                entry.onClick({
+                    editor,
+                    isActive: active
+                });
+            }
+        },
+        ref: ref,
+        title: title,
+        type: "button"
+    }, children);
+}
+function DropDownItems({ children, dropDownRef, onClose }) {
+    const [items, setItems] = (0, _react.useState)();
+    const [highlightedItem, setHighlightedItem] = (0, _react.useState)();
+    const registerItem = (0, _react.useCallback)((itemRef)=>{
+        setItems((prev)=>prev != null ? [
+                ...prev,
+                itemRef
+            ] : [
+                itemRef
+            ]);
+    }, [
+        setItems
+    ]);
+    const handleKeyDown = (event)=>{
+        if (items == null) return;
+        const { key } = event;
+        if ([
+            'ArrowDown',
+            'ArrowUp',
+            'Escape',
+            'Tab'
+        ].includes(key)) {
+            event.preventDefault();
+        }
+        if (key === 'Escape' || key === 'Tab') {
+            onClose();
+        } else if (key === 'ArrowUp') {
+            setHighlightedItem((prev)=>{
+                if (prev == null) return items[0];
+                const index = items.indexOf(prev) - 1;
+                return items[index === -1 ? items.length - 1 : index];
+            });
+        } else if (key === 'ArrowDown') {
+            setHighlightedItem((prev)=>{
+                if (prev == null) return items[0];
+                return items[items.indexOf(prev) + 1];
+            });
+        }
+    };
+    const contextValue = (0, _react.useMemo)(()=>({
+            registerItem
+        }), [
+        registerItem
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (items != null && highlightedItem == null) {
+            setHighlightedItem(items[0]);
+        }
+        if (highlightedItem?.current != null) {
+            highlightedItem.current.focus();
+        }
+    }, [
+        items,
+        highlightedItem
+    ]);
+    return /*#__PURE__*/ _react.createElement(DropDownContext.Provider, {
+        value: contextValue
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: "floating-select-toolbar-popup__dropdown--items",
+        onKeyDown: handleKeyDown,
+        ref: dropDownRef
+    }, children));
+}
+function DropDown({ Icon, buttonAriaLabel, buttonClassName, children, disabled = false, stopCloseOnClickSelf }) {
+    const dropDownRef = (0, _react.useRef)(null);
+    const buttonRef = (0, _react.useRef)(null);
+    const [showDropDown, setShowDropDown] = (0, _react.useState)(false);
+    const handleClose = ()=>{
+        setShowDropDown(false);
+        if (buttonRef?.current != null) {
+            buttonRef.current.focus();
+        }
+    };
+    (0, _react.useEffect)(()=>{
+        const button = buttonRef.current;
+        const dropDown = dropDownRef.current;
+        if (showDropDown && button !== null && dropDown !== null) {
+            const { left, top } = button.getBoundingClientRect();
+            const scrollTopOffset = window.pageYOffset || document.documentElement.scrollTop;
+            dropDown.style.top = `${top + scrollTopOffset + button.offsetHeight + 5}px`;
+            dropDown.style.left = `${Math.min(left - 5, window.innerWidth - dropDown.offsetWidth - 20)}px`;
+        }
+    }, [
+        dropDownRef,
+        buttonRef,
+        showDropDown
+    ]);
+    (0, _react.useEffect)(()=>{
+        const button = buttonRef.current;
+        if (button !== null && showDropDown) {
+            const handle = (event)=>{
+                const { target } = event;
+                if (stopCloseOnClickSelf != null) {
+                    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+                    if (dropDownRef.current != null && dropDownRef.current.contains(target)) {
+                        return;
+                    }
+                }
+                if (!button.contains(target)) {
+                    setShowDropDown(false);
+                }
+            };
+            document.addEventListener('click', handle);
+            return ()=>{
+                document.removeEventListener('click', handle);
+            };
+        }
+    }, [
+        dropDownRef,
+        buttonRef,
+        showDropDown,
+        stopCloseOnClickSelf
+    ]);
+    return /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement("button", {
+        "aria-label": buttonAriaLabel,
+        className: buttonClassName + (showDropDown ? ' active' : ''),
+        disabled: disabled,
+        onClick: (event)=>{
+            event.preventDefault();
+            setShowDropDown(!showDropDown);
+        },
+        ref: buttonRef,
+        type: "button"
+    }, /*#__PURE__*/ _react.createElement(Icon, null), /*#__PURE__*/ _react.createElement("i", {
+        className: `${buttonClassName}--caret`
+    })), showDropDown && /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.createElement(DropDownItems, {
+        dropDownRef: dropDownRef,
+        onClose: handleClose
+    }, children), document.body));
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/DropDown.tsx"],"sourcesContent":["import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport { $getSelection } from 'lexical'\nimport { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport * as React from 'react'\nimport { createPortal } from 'react-dom'\n\nimport type { FloatingToolbarSectionEntry } from '../types'\n\ninterface DropDownContextType {\n  registerItem: (ref: React.RefObject<HTMLButtonElement>) => void\n}\n\nconst DropDownContext = React.createContext<DropDownContextType | null>(null)\n\nexport function DropDownItem({\n  children,\n  entry,\n  title,\n}: {\n  children: React.ReactNode\n  entry: FloatingToolbarSectionEntry\n  title?: string\n}): JSX.Element {\n  const [editor] = useLexicalComposerContext()\n  const [enabled, setEnabled] = useState<boolean>(true)\n  const [active, setActive] = useState<boolean>(false)\n  const [className, setClassName] = useState<string>('item')\n\n  const updateStates = useCallback(() => {\n    editor.getEditorState().read(() => {\n      const selection = $getSelection()\n      if (entry.isActive) {\n        const isActive = entry.isActive({ editor, selection })\n        if (active !== isActive) {\n          setActive(isActive)\n        }\n      }\n      if (entry.isEnabled) {\n        const isEnabled = entry.isEnabled({ editor, selection })\n        if (enabled !== isEnabled) {\n          setEnabled(isEnabled)\n        }\n      }\n    })\n  }, [active, editor, enabled, entry])\n\n  useEffect(() => {\n    updateStates()\n  }, [updateStates])\n\n  useEffect(() => {\n    document.addEventListener('mouseup', updateStates)\n    return () => {\n      document.removeEventListener('mouseup', updateStates)\n    }\n  }, [updateStates])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updateStates()\n      }),\n    )\n  }, [editor, updateStates])\n\n  useEffect(() => {\n    setClassName(\n      ['item', enabled === false ? 'disabled' : '', active ? 'active' : '']\n        .filter(Boolean)\n        .join(' '),\n    )\n  }, [enabled, active, className])\n\n  const ref = useRef<HTMLButtonElement>(null)\n\n  const dropDownContext = React.useContext(DropDownContext)\n\n  if (dropDownContext === null) {\n    throw new Error('DropDownItem must be used within a DropDown')\n  }\n\n  const { registerItem } = dropDownContext\n\n  useEffect(() => {\n    if (ref?.current != null) {\n      registerItem(ref)\n    }\n  }, [ref, registerItem])\n\n  return (\n    <button\n      className={className}\n      onClick={() => {\n        if (enabled !== false) {\n          entry.onClick({\n            editor,\n            isActive: active,\n          })\n        }\n      }}\n      ref={ref}\n      title={title}\n      type=\"button\"\n    >\n      {children}\n    </button>\n  )\n}\n\nfunction DropDownItems({\n  children,\n  dropDownRef,\n  onClose,\n}: {\n  children: React.ReactNode\n  dropDownRef: React.Ref<HTMLDivElement>\n  onClose: () => void\n}): JSX.Element {\n  const [items, setItems] = useState<Array<React.RefObject<HTMLButtonElement>>>()\n  const [highlightedItem, setHighlightedItem] = useState<React.RefObject<HTMLButtonElement>>()\n\n  const registerItem = useCallback(\n    (itemRef: React.RefObject<HTMLButtonElement>) => {\n      setItems((prev) => (prev != null ? [...prev, itemRef] : [itemRef]))\n    },\n    [setItems],\n  )\n\n  const handleKeyDown = (event: React.KeyboardEvent<HTMLDivElement>): void => {\n    if (items == null) return\n\n    const { key } = event\n\n    if (['ArrowDown', 'ArrowUp', 'Escape', 'Tab'].includes(key)) {\n      event.preventDefault()\n    }\n\n    if (key === 'Escape' || key === 'Tab') {\n      onClose()\n    } else if (key === 'ArrowUp') {\n      setHighlightedItem((prev) => {\n        if (prev == null) return items[0]\n        const index = items.indexOf(prev) - 1\n        return items[index === -1 ? items.length - 1 : index]\n      })\n    } else if (key === 'ArrowDown') {\n      setHighlightedItem((prev) => {\n        if (prev == null) return items[0]\n        return items[items.indexOf(prev) + 1]\n      })\n    }\n  }\n\n  const contextValue = useMemo(\n    () => ({\n      registerItem,\n    }),\n    [registerItem],\n  )\n\n  useEffect(() => {\n    if (items != null && highlightedItem == null) {\n      setHighlightedItem(items[0])\n    }\n\n    if (highlightedItem?.current != null) {\n      highlightedItem.current.focus()\n    }\n  }, [items, highlightedItem])\n\n  return (\n    <DropDownContext.Provider value={contextValue}>\n      <div\n        className=\"floating-select-toolbar-popup__dropdown--items\"\n        onKeyDown={handleKeyDown}\n        ref={dropDownRef}\n      >\n        {children}\n      </div>\n    </DropDownContext.Provider>\n  )\n}\n\nexport function DropDown({\n  Icon,\n  buttonAriaLabel,\n  buttonClassName,\n  children,\n  disabled = false,\n  stopCloseOnClickSelf,\n}: {\n  Icon?: React.FC\n  buttonAriaLabel?: string\n  buttonClassName: string\n  children: ReactNode\n  disabled?: boolean\n  stopCloseOnClickSelf?: boolean\n}): JSX.Element {\n  const dropDownRef = useRef<HTMLDivElement>(null)\n  const buttonRef = useRef<HTMLButtonElement>(null)\n  const [showDropDown, setShowDropDown] = useState(false)\n\n  const handleClose = (): void => {\n    setShowDropDown(false)\n    if (buttonRef?.current != null) {\n      buttonRef.current.focus()\n    }\n  }\n\n  useEffect(() => {\n    const button = buttonRef.current\n    const dropDown = dropDownRef.current\n\n    if (showDropDown && button !== null && dropDown !== null) {\n      const { left, top } = button.getBoundingClientRect()\n      const scrollTopOffset = window.pageYOffset || document.documentElement.scrollTop\n      dropDown.style.top = `${top + scrollTopOffset + button.offsetHeight + 5}px`\n      dropDown.style.left = `${Math.min(left - 5, window.innerWidth - dropDown.offsetWidth - 20)}px`\n    }\n  }, [dropDownRef, buttonRef, showDropDown])\n\n  useEffect(() => {\n    const button = buttonRef.current\n\n    if (button !== null && showDropDown) {\n      const handle = (event: MouseEvent): void => {\n        const { target } = event\n        if (stopCloseOnClickSelf != null) {\n          // eslint-disable-next-line @typescript-eslint/prefer-optional-chain\n          if (dropDownRef.current != null && dropDownRef.current.contains(target as Node)) {\n            return\n          }\n        }\n        if (!button.contains(target as Node)) {\n          setShowDropDown(false)\n        }\n      }\n      document.addEventListener('click', handle)\n\n      return () => {\n        document.removeEventListener('click', handle)\n      }\n    }\n  }, [dropDownRef, buttonRef, showDropDown, stopCloseOnClickSelf])\n\n  return (\n    <React.Fragment>\n      <button\n        aria-label={buttonAriaLabel}\n        className={buttonClassName + (showDropDown ? ' active' : '')}\n        disabled={disabled}\n        onClick={(event) => {\n          event.preventDefault()\n          setShowDropDown(!showDropDown)\n        }}\n        ref={buttonRef}\n        type=\"button\"\n      >\n        <Icon />\n        <i className={`${buttonClassName}--caret`} />\n      </button>\n\n      {showDropDown &&\n        createPortal(\n          <DropDownItems dropDownRef={dropDownRef} onClose={handleClose}>\n            {children}\n          </DropDownItems>,\n          document.body,\n        )}\n    </React.Fragment>\n  )\n}\n"],"names":["DropDownItem","DropDown","DropDownContext","React","createContext","children","entry","title","editor","useLexicalComposerContext","enabled","setEnabled","useState","active","setActive","className","setClassName","updateStates","useCallback","getEditorState","read","selection","$getSelection","isActive","isEnabled","useEffect","document","addEventListener","removeEventListener","mergeRegister","registerUpdateListener","filter","Boolean","join","ref","useRef","dropDownContext","useContext","Error","registerItem","current","button","onClick","type","DropDownItems","dropDownRef","onClose","items","setItems","highlightedItem","setHighlightedItem","itemRef","prev","handleKeyDown","event","key","includes","preventDefault","index","indexOf","length","contextValue","useMemo","focus","Provider","value","div","onKeyDown","Icon","buttonAriaLabel","buttonClassName","disabled","stopCloseOnClickSelf","buttonRef","showDropDown","setShowDropDown","handleClose","dropDown","left","top","getBoundingClientRect","scrollTopOffset","window","pageYOffset","documentElement","scrollTop","style","offsetHeight","Math","min","innerWidth","offsetWidth","handle","target","contains","Fragment","aria-label","i","createPortal","body"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { FloatingToolbarSectionEntry } from '../types';
+import './index.scss';
+export declare const ToolbarDropdown: ({ Icon, classNames, entries, }: {
+    Icon?: React.FC;
+    classNames?: string[];
+    entries: FloatingToolbarSectionEntry[];
+}) => React.JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/FloatingSelectToolbar/ToolbarDropdown/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAA;AAG3D,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,eAAe;WAKnB,MAAM,EAAE;iBACF,MAAM,EAAE;aACZ,2BAA2B,EAAE;uBAiBvC,CAAA"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarDropdown", {
+    enumerable: true,
+    get: function() {
+        return ToolbarDropdown;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _DropDown = require("./DropDown");
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const baseClass = 'floating-select-toolbar-popup__dropdown';
+const ToolbarDropdown = ({ Icon, classNames, entries })=>{
+    return /*#__PURE__*/ _react.default.createElement(_DropDown.DropDown, {
+        Icon: Icon,
+        buttonAriaLabel: "Formatting options",
+        buttonClassName: [
+            baseClass,
+            ...classNames || []
+        ].filter(Boolean).join(' ')
+    }, entries.length && entries.map((entry)=>/*#__PURE__*/ _react.default.createElement(_DropDown.DropDownItem, {
+            entry: entry,
+            key: entry.key
+        }, /*#__PURE__*/ _react.default.createElement(entry.ChildComponent, null), /*#__PURE__*/ _react.default.createElement("span", {
+            className: "text"
+        }, entry.label))));
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL3BsdWdpbnMvRmxvYXRpbmdTZWxlY3RUb29sYmFyL1Rvb2xiYXJEcm9wZG93bi9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuXG5jb25zdCBiYXNlQ2xhc3MgPSAnZmxvYXRpbmctc2VsZWN0LXRvb2xiYXItcG9wdXBfX2Ryb3Bkb3duJ1xuXG5pbXBvcnQgdHlwZSB7IEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBEcm9wRG93biwgRHJvcERvd25JdGVtIH0gZnJvbSAnLi9Ecm9wRG93bidcbmltcG9ydCAnLi9pbmRleC5zY3NzJ1xuXG5leHBvcnQgY29uc3QgVG9vbGJhckRyb3Bkb3duID0gKHtcbiAgSWNvbixcbiAgY2xhc3NOYW1lcyxcbiAgZW50cmllcyxcbn06IHtcbiAgSWNvbj86IFJlYWN0LkZDXG4gIGNsYXNzTmFtZXM/OiBzdHJpbmdbXVxuICBlbnRyaWVzOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uRW50cnlbXVxufSkgPT4ge1xuICByZXR1cm4gKFxuICAgIDxEcm9wRG93blxuICAgICAgSWNvbj17SWNvbn1cbiAgICAgIGJ1dHRvbkFyaWFMYWJlbD1cIkZvcm1hdHRpbmcgb3B0aW9uc1wiXG4gICAgICBidXR0b25DbGFzc05hbWU9e1tiYXNlQ2xhc3MsIC4uLihjbGFzc05hbWVzIHx8IFtdKV0uZmlsdGVyKEJvb2xlYW4pLmpvaW4oJyAnKX1cbiAgICA+XG4gICAgICB7ZW50cmllcy5sZW5ndGggJiZcbiAgICAgICAgZW50cmllcy5tYXAoKGVudHJ5KSA9PiAoXG4gICAgICAgICAgPERyb3BEb3duSXRlbSBlbnRyeT17ZW50cnl9IGtleT17ZW50cnkua2V5fT5cbiAgICAgICAgICAgIDxlbnRyeS5DaGlsZENvbXBvbmVudCAvPlxuICAgICAgICAgICAgPHNwYW4gY2xhc3NOYW1lPVwidGV4dFwiPntlbnRyeS5sYWJlbH08L3NwYW4+XG4gICAgICAgICAgPC9Ecm9wRG93bkl0ZW0+XG4gICAgICAgICkpfVxuICAgIDwvRHJvcERvd24+XG4gIClcbn1cbiJdLCJuYW1lcyI6WyJUb29sYmFyRHJvcGRvd24iLCJiYXNlQ2xhc3MiLCJJY29uIiwiY2xhc3NOYW1lcyIsImVudHJpZXMiLCJEcm9wRG93biIsImJ1dHRvbkFyaWFMYWJlbCIsImJ1dHRvbkNsYXNzTmFtZSIsImZpbHRlciIsIkJvb2xlYW4iLCJqb2luIiwibGVuZ3RoIiwibWFwIiwiZW50cnkiLCJEcm9wRG93bkl0ZW0iLCJrZXkiLCJDaGlsZENvbXBvbmVudCIsInNwYW4iLCJjbGFzc05hbWUiLCJsYWJlbCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFTYUE7OztlQUFBQTs7OzhEQVRLOzBCQU1xQjtRQUNoQzs7Ozs7O0FBTFAsTUFBTUMsWUFBWTtBQU9YLE1BQU1ELGtCQUFrQixDQUFDLEVBQzlCRSxJQUFJLEVBQ0pDLFVBQVUsRUFDVkMsT0FBTyxFQUtSO0lBQ0MscUJBQ0UsNkJBQUNDLGtCQUFRO1FBQ1BILE1BQU1BO1FBQ05JLGlCQUFnQjtRQUNoQkMsaUJBQWlCO1lBQUNOO2VBQWVFLGNBQWMsRUFBRTtTQUFFLENBQUNLLE1BQU0sQ0FBQ0MsU0FBU0MsSUFBSSxDQUFDO09BRXhFTixRQUFRTyxNQUFNLElBQ2JQLFFBQVFRLEdBQUcsQ0FBQyxDQUFDQyxzQkFDWCw2QkFBQ0Msc0JBQVk7WUFBQ0QsT0FBT0E7WUFBT0UsS0FBS0YsTUFBTUUsR0FBRzt5QkFDeEMsNkJBQUNGLE1BQU1HLGNBQWMsdUJBQ3JCLDZCQUFDQztZQUFLQyxXQUFVO1dBQVFMLE1BQU1NLEtBQUs7QUFLL0MifQ==

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import './index.scss';
+export declare function FloatingSelectToolbarPlugin({ anchorElem, }: {
+    anchorElem?: HTMLElement;
+}): JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

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

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