@byline/richtext-lexical 0.9.3

package/dist/field/plugins/auto-embed-plugin/index.js

@@ -0,0 +1,152 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { AutoEmbedOption, LexicalAutoEmbedPlugin } from "@lexical/react/LexicalAutoEmbedPlugin";
+import { INSERT_VIMEO_COMMAND } from "../vimeo-plugin/index.js";
+import { INSERT_YOUTUBE_COMMAND } from "../youtube-plugin/index.js";
+import { AutoEmbedModal } from "./auto-embed-modal.js";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+const YoutubeEmbedConfig = {
+    contentName: 'Youtube Video',
+    exampleUrl: 'https://www.youtube.com/watch?v=jNQXAC9IVRw',
+    icon: /*#__PURE__*/ jsx("i", {
+        className: "icon youtube"
+    }),
+    insertNode: (editor, result)=>{
+        editor.dispatchCommand(INSERT_YOUTUBE_COMMAND, result.id);
+    },
+    keywords: [
+        'youtube',
+        'video'
+    ],
+    parseUrl: async (url)=>{
+        const match = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/.exec(url);
+        const id = null != match ? match?.[2].length === 11 ? match[2] : null : null;
+        if (null != id) return {
+            id,
+            url
+        };
+        return null;
+    },
+    type: 'youtube-video'
+};
+const VimeoEmbedConfig = {
+    contentName: 'Vimeo Video',
+    exampleUrl: 'https://vimeo.com/584985260',
+    icon: /*#__PURE__*/ jsx("i", {
+        className: "icon vimeo"
+    }),
+    insertNode: (editor, result)=>{
+        editor.dispatchCommand(INSERT_VIMEO_COMMAND, result.id);
+    },
+    keywords: [
+        'vimeo',
+        'video'
+    ],
+    parseUrl: async (url)=>{
+        const match = /https:\/\/vimeo\.com\/(\d{5,10})/.exec(url);
+        const id = null != match ? match[1] : null;
+        if (null != id) return {
+            id,
+            url
+        };
+        return null;
+    },
+    type: 'vimeo-video'
+};
+const EmbedConfigs = [
+    YoutubeEmbedConfig,
+    VimeoEmbedConfig
+];
+function AutoEmbedMenuItem({ index, isSelected, onClick, onMouseEnter, option }) {
+    let className = 'item';
+    if (isSelected) className += ' selected';
+    const handleKeyDown = (event)=>{
+        if ('Enter' === event.key || ' ' === event.key) {
+            event.preventDefault();
+            onClick();
+        }
+    };
+    return /*#__PURE__*/ jsx("li", {
+        className: className,
+        ref: option.setRefElement,
+        id: `typeahead-item-${index}`,
+        onMouseEnter: onMouseEnter,
+        onClick: onClick,
+        onKeyDown: handleKeyDown,
+        children: /*#__PURE__*/ jsx("span", {
+            className: "text",
+            children: option.title
+        })
+    }, option.key);
+}
+function AutoEmbedMenu({ options, selectedItemIndex, onOptionClick, onOptionMouseEnter }) {
+    return /*#__PURE__*/ jsx("div", {
+        className: "typeahead-popover",
+        children: /*#__PURE__*/ jsx("ul", {
+            children: options.map((option, i)=>/*#__PURE__*/ jsx(AutoEmbedMenuItem, {
+                    index: i,
+                    isSelected: selectedItemIndex === i,
+                    onClick: ()=>{
+                        onOptionClick(option, i);
+                    },
+                    onMouseEnter: ()=>{
+                        onOptionMouseEnter(i);
+                    },
+                    option: option
+                }, option.key))
+        })
+    });
+}
+function AutoEmbedPlugin() {
+    const [open, setOpen] = useState(false);
+    const [embedConfig, setEmbedConfig] = useState(null);
+    const handleOnOpenEmbedModalForConfig = (config)=>{
+        setEmbedConfig(config);
+        setOpen(true);
+    };
+    const getMenuOptions = (activeEmbedConfig, embedFn, dismissFn)=>[
+            new AutoEmbedOption('Dismiss', {
+                onSelect: dismissFn
+            }),
+            new AutoEmbedOption(`Embed ${activeEmbedConfig.contentName}`, {
+                onSelect: embedFn
+            })
+        ];
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(LexicalAutoEmbedPlugin, {
+                embedConfigs: EmbedConfigs,
+                onOpenEmbedModalForConfig: handleOnOpenEmbedModalForConfig,
+                getMenuOptions: getMenuOptions,
+                menuRenderFn: (anchorElementRef, { selectedIndex, options, selectOptionAndCleanUp, setHighlightedIndex })=>null != anchorElementRef.current ? /*#__PURE__*/ __rspack_external_react_dom_7136dc57.createPortal(/*#__PURE__*/ jsx("div", {
+                        className: "typeahead-popover auto-embed-menu",
+                        style: {
+                            marginLeft: anchorElementRef.current.style.width,
+                            width: 200
+                        },
+                        children: /*#__PURE__*/ jsx(AutoEmbedMenu, {
+                            options: options,
+                            selectedItemIndex: selectedIndex,
+                            onOptionClick: (option, index)=>{
+                                setHighlightedIndex(index);
+                                selectOptionAndCleanUp(option);
+                            },
+                            onOptionMouseEnter: (index)=>{
+                                setHighlightedIndex(index);
+                            }
+                        })
+                    }), anchorElementRef.current) : null
+            }),
+            /*#__PURE__*/ jsx(AutoEmbedModal, {
+                open: open,
+                embedConfig: embedConfig,
+                onClose: ()=>{
+                    setOpen(false);
+                    setEmbedConfig(null);
+                }
+            })
+        ]
+    });
+}
+export { AutoEmbedPlugin, EmbedConfigs, VimeoEmbedConfig, YoutubeEmbedConfig };

package/dist/field/plugins/code-highlight-plugin/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type * as React from 'react';
+export declare function CodeHighlightPlugin(): React.JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/plugins/code-highlight-plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/plugins/code-highlight-plugin/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAMnC,wBAAgB,mBAAmB,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAQ9D"}

package/dist/field/plugins/code-highlight-plugin/index.js

@@ -0,0 +1,11 @@
+import { useEffect } from "react";
+import { registerCodeHighlighting } from "@lexical/code";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+function CodeHighlightPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>registerCodeHighlighting(editor), [
+        editor
+    ]);
+    return null;
+}
+export { CodeHighlightPlugin };

package/dist/field/plugins/drag-drop-paste-plugin/index.js

@@ -0,0 +1 @@
+export { };

package/dist/field/plugins/floating-text-format-toolbar-plugin/index.css

@@ -0,0 +1,148 @@
+.floating-text-format-popup {
+  vertical-align: middle;
+  z-index: 10;
+  opacity: 0;
+  will-change: transform;
+  background: #fff;
+  border-radius: 6px;
+  height: 35px;
+  padding: 4px;
+  transition: opacity .5s;
+  display: flex;
+  position: absolute;
+  top: 0;
+  left: 0;
+  box-shadow: 0 5px 10px #0000004d;
+}
+
+.floating-text-format-popup button.popup-item {
+  cursor: pointer;
+  vertical-align: middle;
+  background: none;
+  border: 0;
+  border-radius: 6px;
+  display: flex;
+}
+
+.floating-text-format-popup button.popup-item:disabled {
+  cursor: not-allowed;
+}
+
+.floating-text-format-popup button.popup-item.spaced {
+  margin-right: 2px;
+}
+
+.floating-text-format-popup button.popup-item i.format {
+  vertical-align: -.25em;
+  opacity: .6;
+  background-size: contain;
+  width: 18px;
+  height: 18px;
+  margin-top: 3px;
+  display: inline-block;
+}
+
+.floating-text-format-popup button.popup-item:disabled i.format {
+  opacity: .2;
+}
+
+.floating-text-format-popup button.popup-item.active {
+  background-color: #dfe8fa4d;
+}
+
+.floating-text-format-popup button.popup-item.active i {
+  opacity: 1;
+}
+
+.floating-text-format-popup .popup-item:hover:not([disabled]) {
+  background-color: #eee;
+}
+
+.floating-text-format-popup select.popup-item {
+  vertical-align: middle;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  color: #777;
+  text-overflow: ellipsis;
+  background: none;
+  border: 0;
+  border-radius: 6px;
+  width: 70px;
+  padding: 8px;
+  font-size: 14px;
+  display: flex;
+}
+
+.floating-text-format-popup select.code-language {
+  text-transform: capitalize;
+  width: 130px;
+}
+
+.floating-text-format-popup .popup-item .text {
+  vertical-align: middle;
+  color: #777;
+  text-overflow: ellipsis;
+  text-align: left;
+  width: 200px;
+  height: 20px;
+  font-size: 14px;
+  line-height: 20px;
+  display: flex;
+  overflow: hidden;
+}
+
+.floating-text-format-popup .popup-item .icon {
+  -webkit-user-select: none;
+  user-select: none;
+  background-size: contain;
+  width: 20px;
+  height: 20px;
+  margin-right: 8px;
+  line-height: 16px;
+  display: flex;
+}
+
+.floating-text-format-popup i.chevron-down {
+  -webkit-user-select: none;
+  user-select: none;
+  width: 16px;
+  height: 16px;
+  margin-top: 3px;
+  display: flex;
+}
+
+.floating-text-format-popup i.chevron-down.inside {
+  pointer-events: none;
+  width: 16px;
+  height: 16px;
+  margin-top: 11px;
+  margin-left: -25px;
+  margin-right: 10px;
+  display: flex;
+}
+
+.floating-text-format-popup .divider {
+  background-color: #eee;
+  width: 1px;
+  margin: 0 4px;
+}
+
+@media (max-width: 1024px) {
+  .floating-text-format-popup button.insert-comment {
+    display: none;
+  }
+}
+
+.dark .floating-text-format-popup {
+  background-color: var(--canvas-800);
+  border: 1px solid var(--border-color);
+}
+
+.dark .floating-text-format-popup i {
+  filter: invert();
+}
+
+.dark .floating-text-format-popup .popup-item:hover:not([disabled]) {
+  background-color: #1c1c1c;
+}
+

package/dist/field/plugins/floating-text-format-toolbar-plugin/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import './index.css';
+import type * as React from 'react';
+export declare function FloatingTextFormatToolbarPlugin({ anchorElem, }: {
+    anchorElem?: HTMLElement;
+}): React.JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/plugins/floating-text-format-toolbar-plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/plugins/floating-text-format-toolbar-plugin/index.tsx"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,aAAa,CAAA;AAEpB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AA2XnC,wBAAgB,+BAA+B,CAAC,EAC9C,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAG3B"}

package/dist/field/plugins/floating-text-format-toolbar-plugin/index.js

@@ -0,0 +1,279 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import "./index.css";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { $isCodeHighlightNode } from "@lexical/code";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister } from "@lexical/utils";
+import { $getSelection, $isParagraphNode, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND, SELECTION_CHANGE_COMMAND } from "lexical";
+import { createPortal } from "react-dom";
+import { $isLinkNode, TOGGLE_LINK_COMMAND } from "../../nodes/link-nodes/index.js";
+import { getDOMRangeRect } from "../../utils/getDOMRangeRect.js";
+import { getSelectedNode } from "../../utils/getSelectedNode.js";
+import { setFloatingElemPosition } from "../../utils/setFloatingElemPosition.js";
+function TextFormatFloatingToolbar({ editor, anchorElem, isLink, isBold, isItalic, isUnderline, isCode, isStrikethrough, isSubscript, isSuperscript }) {
+    const popupCharStylesEditorRef = useRef(null);
+    const handleOnInsertLink = useCallback(()=>{
+        if (isLink) editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+        else {
+            const editorState = editor.getEditorState();
+            editorState.read(()=>{
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    if (selection.focus.offset !== selection.anchor.offset) {
+                        const linkAttributes = {
+                            linkType: 'custom',
+                            url: 'https://'
+                        };
+                        editor.dispatchCommand(TOGGLE_LINK_COMMAND, linkAttributes);
+                    }
+                }
+            });
+        }
+    }, [
+        editor,
+        isLink
+    ]);
+    function mouseMoveListener(e) {
+        if (popupCharStylesEditorRef?.current != null && (1 === e.buttons || 3 === e.buttons)) {
+            if ('none' !== popupCharStylesEditorRef.current.style.pointerEvents) {
+                const x = e.clientX;
+                const y = e.clientY;
+                const elementUnderMouse = document.elementFromPoint(x, y);
+                if (!popupCharStylesEditorRef.current.contains(elementUnderMouse)) popupCharStylesEditorRef.current.style.pointerEvents = 'none';
+            }
+        }
+    }
+    function mouseUpListener(_e) {
+        if (popupCharStylesEditorRef?.current != null) {
+            if ('auto' !== popupCharStylesEditorRef.current.style.pointerEvents) popupCharStylesEditorRef.current.style.pointerEvents = 'auto';
+        }
+    }
+    useEffect(()=>{
+        if (popupCharStylesEditorRef?.current != null) {
+            document.addEventListener('mousemove', mouseMoveListener);
+            document.addEventListener('mouseup', mouseUpListener);
+            return ()=>{
+                document.removeEventListener('mousemove', mouseMoveListener);
+                document.removeEventListener('mouseup', mouseUpListener);
+            };
+        }
+    }, [
+        popupCharStylesEditorRef
+    ]);
+    const updateTextFormatFloatingToolbar = useCallback(()=>{
+        const selection = $getSelection();
+        const popupCharStylesEditorElem = popupCharStylesEditorRef.current;
+        const nativeSelection = window.getSelection();
+        if (null === popupCharStylesEditorElem) return;
+        const rootElement = editor.getRootElement();
+        if (null !== selection && null !== nativeSelection && !nativeSelection.isCollapsed && rootElement?.contains(nativeSelection.anchorNode)) {
+            const rangeRect = getDOMRangeRect(nativeSelection, rootElement);
+            setFloatingElemPosition(rangeRect, popupCharStylesEditorElem, anchorElem, isLink);
+        }
+    }, [
+        editor,
+        anchorElem,
+        isLink
+    ]);
+    useEffect(()=>{
+        const scrollerElem = anchorElem.parentElement;
+        const update = ()=>{
+            editor.getEditorState().read(()=>{
+                updateTextFormatFloatingToolbar();
+            });
+        };
+        window.addEventListener('resize', update);
+        if (null != scrollerElem) scrollerElem.addEventListener('scroll', update);
+        return ()=>{
+            window.removeEventListener('resize', update);
+            if (null != 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__*/ jsx("div", {
+        ref: popupCharStylesEditorRef,
+        className: "floating-text-format-popup",
+        children: editor.isEditable() && /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
+                    },
+                    className: `popup-item spaced ${isBold ? 'active' : ''}`,
+                    "aria-label": "Format text as bold",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format bold"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
+                    },
+                    className: `popup-item spaced ${isItalic ? 'active' : ''}`,
+                    "aria-label": "Format text as italics",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format italic"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
+                    },
+                    className: `popup-item spaced ${isUnderline ? 'active' : ''}`,
+                    "aria-label": "Format text to underlined",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format underline"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
+                    },
+                    className: `popup-item spaced ${isStrikethrough ? 'active' : ''}`,
+                    "aria-label": "Format text with a strikethrough",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format strikethrough"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, "subscript");
+                    },
+                    className: `popup-item spaced ${isSubscript ? 'active' : ''}`,
+                    title: "Subscript",
+                    "aria-label": "Format Subscript",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format subscript"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, "superscript");
+                    },
+                    className: `popup-item spaced ${isSuperscript ? 'active' : ''}`,
+                    title: "Superscript",
+                    "aria-label": "Format Superscript",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format superscript"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'code');
+                    },
+                    className: `popup-item spaced ${isCode ? 'active' : ''}`,
+                    "aria-label": "Insert code block",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format code"
+                    })
+                }),
+                /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    onClick: handleOnInsertLink,
+                    className: `popup-item spaced ${isLink ? 'active' : ''}`,
+                    "aria-label": "Insert link",
+                    children: /*#__PURE__*/ jsx("i", {
+                        className: "format link"
+                    })
+                })
+            ]
+        })
+    });
+}
+function useFloatingTextFormatToolbar(editor, anchorElem) {
+    const [isText, setIsText] = useState(false);
+    const [isLink, setIsLink] = useState(false);
+    const [isBold, setIsBold] = useState(false);
+    const [isItalic, setIsItalic] = useState(false);
+    const [isUnderline, setIsUnderline] = useState(false);
+    const [isStrikethrough, setIsStrikethrough] = useState(false);
+    const [isSubscript, setIsSubscript] = useState(false);
+    const [isSuperscript, setIsSuperscript] = useState(false);
+    const [isCode, setIsCode] = useState(false);
+    const updatePopup = useCallback(()=>{
+        editor.getEditorState().read(()=>{
+            if (editor.isComposing()) return;
+            const selection = $getSelection();
+            const nativeSelection = window.getSelection();
+            const rootElement = editor.getRootElement();
+            if (null !== nativeSelection && (!$isRangeSelection(selection) || null === rootElement || !rootElement.contains(nativeSelection.anchorNode))) return void setIsText(false);
+            if (!$isRangeSelection(selection)) return;
+            const node = getSelectedNode(selection);
+            setIsBold(selection.hasFormat('bold'));
+            setIsItalic(selection.hasFormat('italic'));
+            setIsUnderline(selection.hasFormat('underline'));
+            setIsStrikethrough(selection.hasFormat('strikethrough'));
+            setIsSubscript(selection.hasFormat("subscript"));
+            setIsSuperscript(selection.hasFormat("superscript"));
+            setIsCode(selection.hasFormat('code'));
+            const parent = node.getParent();
+            $isLinkNode(parent) || $isLinkNode(node) ? setIsLink(true) : setIsLink(false);
+            $isCodeHighlightNode(selection.anchor.getNode()) || '' === selection.getTextContent() ? setIsText(false) : setIsText($isTextNode(node) || $isParagraphNode(node));
+            const rawTextContent = selection.getTextContent().replace(/\n/g, '');
+            if (!selection.isCollapsed() && '' === rawTextContent) setIsText(false);
+        });
+    }, [
+        editor
+    ]);
+    useEffect(()=>{
+        document.addEventListener('selectionchange', updatePopup);
+        return ()=>{
+            document.removeEventListener('selectionchange', updatePopup);
+        };
+    }, [
+        updatePopup
+    ]);
+    useEffect(()=>mergeRegister(editor.registerUpdateListener(()=>{
+            updatePopup();
+        }), editor.registerRootListener(()=>{
+            if (null === editor.getRootElement()) setIsText(false);
+        })), [
+        editor,
+        updatePopup
+    ]);
+    if (!isText) return null;
+    return /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx(TextFormatFloatingToolbar, {
+        editor: editor,
+        anchorElem: anchorElem,
+        isLink: isLink,
+        isBold: isBold,
+        isItalic: isItalic,
+        isStrikethrough: isStrikethrough,
+        isSubscript: isSubscript,
+        isSuperscript: isSuperscript,
+        isUnderline: isUnderline,
+        isCode: isCode
+    }), anchorElem);
+}
+function FloatingTextFormatToolbarPlugin({ anchorElem = document.body }) {
+    const [editor] = useLexicalComposerContext();
+    return useFloatingTextFormatToolbar(editor, anchorElem);
+}
+export { FloatingTextFormatToolbarPlugin };

package/dist/field/plugins/inline-image-plugin/fields.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { SelectValue } from '@infonomic/uikit/react';
+export declare const positionOptions: SelectValue[];
+/** Alt text is required for accessibility — non-empty after trimming. */
+export declare function isAltTextValid(value: string | undefined | null): boolean;
+//# sourceMappingURL=fields.d.ts.map

package/dist/field/plugins/inline-image-plugin/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../../src/field/plugins/inline-image-plugin/fields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD,eAAO,MAAM,eAAe,EAAE,WAAW,EAKxC,CAAA;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAExE"}

package/dist/field/plugins/inline-image-plugin/fields.js

@@ -0,0 +1,22 @@
+const positionOptions = [
+    {
+        label: 'Full',
+        value: 'full'
+    },
+    {
+        label: 'Wide',
+        value: 'wide'
+    },
+    {
+        label: 'Left',
+        value: 'left'
+    },
+    {
+        label: 'Right',
+        value: 'right'
+    }
+];
+function isAltTextValid(value) {
+    return 'string' == typeof value && value.trim().length > 0;
+}
+export { isAltTextValid, positionOptions };