@uipath/apollo-wind 2.22.0 → 2.24.0

package/dist/components/ui/prompt-editor/plugins/AutocompletePlugin.cjs

@@ -0,0 +1,242 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AutocompletePlugin: ()=>AutocompletePlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const utils_namespaceObject = require("@lexical/utils");
+const external_lexical_namespaceObject = require("lexical");
+const external_react_namespaceObject = require("react");
+const PromptEditorAutocompleteMenu_cjs_namespaceObject = require("../components/PromptEditorAutocompleteMenu.cjs");
+const autocomplete_segments_cjs_namespaceObject = require("../utils/autocomplete-segments.cjs");
+const insert_token_cjs_namespaceObject = require("../utils/insert-token.cjs");
+const findTrigger = (text, cursorPos)=>{
+    let triggerIndex = -1;
+    for(let i = cursorPos - 1; i >= 0; i--){
+        const char = text[i];
+        if (/\s/.test(char)) break;
+        if ('$' === char) {
+            if (0 === i || /\s/.test(text[i - 1])) triggerIndex = i;
+            break;
+        }
+    }
+    if (-1 === triggerIndex) return null;
+    return {
+        triggerIndex,
+        query: text.slice(triggerIndex + 1, cursorPos)
+    };
+};
+const getCaretRectForEditor = (editor)=>{
+    const rootElement = editor.getRootElement();
+    const fallbackRect = rootElement?.getBoundingClientRect() ?? new DOMRect();
+    const domSelection = (0, external_lexical_namespaceObject.getDOMSelectionFromTarget)(rootElement);
+    if (!domSelection || 0 === domSelection.rangeCount) return fallbackRect;
+    const range = domSelection.getRangeAt(0).cloneRange();
+    range.collapse(false);
+    const rects = 'function' == typeof range.getClientRects ? range.getClientRects() : null;
+    const rect = rects?.item(0) ?? range.getBoundingClientRect();
+    if (!Number.isFinite(rect.x) || !Number.isFinite(rect.y)) return fallbackRect;
+    if (0 === rect.width && 0 === rect.height) return fallbackRect;
+    return rect;
+};
+const AutocompletePlugin = ({ options })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const [open, setOpen] = (0, external_react_namespaceObject.useState)(false);
+    const [anchorEl, setAnchorEl] = (0, external_react_namespaceObject.useState)(null);
+    const [query, setQuery] = (0, external_react_namespaceObject.useState)('');
+    const triggerInfoRef = (0, external_react_namespaceObject.useRef)(null);
+    const dismissedTriggerRef = (0, external_react_namespaceObject.useRef)(null);
+    const optionsRef = (0, external_react_namespaceObject.useRef)(options);
+    const openRef = (0, external_react_namespaceObject.useRef)(open);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        optionsRef.current = options;
+        openRef.current = open;
+    });
+    const closeMenu = (0, external_react_namespaceObject.useCallback)((explicit = false)=>{
+        const wasOpen = openRef.current;
+        if (explicit && triggerInfoRef.current) dismissedTriggerRef.current = {
+            ...triggerInfoRef.current
+        };
+        setOpen(false);
+        setAnchorEl(null);
+        if (!explicit) triggerInfoRef.current = null;
+        if (wasOpen) editor.focus();
+    }, [
+        editor
+    ]);
+    const commitChip = (0, external_react_namespaceObject.useCallback)((option)=>{
+        const triggerInfo = triggerInfoRef.current;
+        if (!triggerInfo) return;
+        editor.update(()=>{
+            const selection = (0, external_lexical_namespaceObject.$getSelection)();
+            if (!selection || !(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return;
+            const anchorNode = selection.anchor.getNode();
+            if (!(0, external_lexical_namespaceObject.$isTextNode)(anchorNode)) return;
+            if (anchorNode.getKey() !== triggerInfo.nodeKey) return;
+            const textContent = anchorNode.getTextContent();
+            const cursorOffset = selection.anchor.offset;
+            const textBefore = textContent.slice(0, triggerInfo.triggerIndex);
+            const textAfter = textContent.slice(cursorOffset);
+            const tokenNode = (0, insert_token_cjs_namespaceObject.createTokenNodeForOption)(option);
+            if (textBefore) {
+                anchorNode.setTextContent(textBefore);
+                anchorNode.insertAfter(tokenNode);
+            } else anchorNode.replace(tokenNode);
+            if (textAfter) {
+                const textAfterNode = (0, external_lexical_namespaceObject.$createTextNode)(textAfter);
+                tokenNode.insertAfter(textAfterNode);
+                textAfterNode.select(0, 0);
+            } else tokenNode.selectNext(0, 0);
+        });
+        closeMenu();
+    }, [
+        closeMenu,
+        editor
+    ]);
+    const commitTypedAsChip = (0, external_react_namespaceObject.useCallback)(()=>{
+        const triggerInfo = triggerInfoRef.current;
+        if (!triggerInfo) return false;
+        let committed = false;
+        editor.read(()=>{
+            const selection = (0, external_lexical_namespaceObject.$getSelection)();
+            if (!selection || !(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return;
+            const anchorNode = selection.anchor.getNode();
+            if (!(0, external_lexical_namespaceObject.$isTextNode)(anchorNode)) return;
+            if (anchorNode.getKey() !== triggerInfo.nodeKey) return;
+            const textContent = anchorNode.getTextContent();
+            const cursorOffset = selection.anchor.offset;
+            const typedQuery = textContent.slice(triggerInfo.triggerIndex + 1, cursorOffset);
+            if (!autocomplete_segments_cjs_namespaceObject.VARIABLE_PATH_REGEX.test(typedQuery)) return;
+            const inferredType = (0, autocomplete_segments_cjs_namespaceObject.inferTokenTypeFromPath)(typedQuery, optionsRef.current);
+            committed = true;
+            queueMicrotask(()=>commitChip({
+                    type: inferredType,
+                    value: typedQuery
+                }));
+        });
+        return committed;
+    }, [
+        commitChip,
+        editor
+    ]);
+    const openPickerForTrigger = (0, external_react_namespaceObject.useCallback)((trigger, anchorNodeKey)=>{
+        triggerInfoRef.current = {
+            triggerIndex: trigger.triggerIndex,
+            nodeKey: anchorNodeKey
+        };
+        setQuery(trigger.query);
+        try {
+            const domSelection = (0, external_lexical_namespaceObject.getDOMSelectionFromTarget)(editor.getRootElement());
+            if (domSelection && domSelection.rangeCount > 0) {
+                const editorRoot = editor.getRootElement();
+                const caretRect = getCaretRectForEditor(editor);
+                const editorRect = editorRoot?.getBoundingClientRect() ?? new DOMRect();
+                const offsetTop = caretRect.top - editorRect.top;
+                const offsetLeft = caretRect.left - editorRect.left;
+                const caretWidth = caretRect.width;
+                const caretHeight = caretRect.height;
+                setAnchorEl({
+                    getBoundingClientRect: ()=>{
+                        const live = editorRoot?.getBoundingClientRect() ?? new DOMRect();
+                        return new DOMRect(live.left + offsetLeft, live.top + offsetTop, caretWidth, caretHeight);
+                    },
+                    contextElement: editorRoot ?? void 0
+                });
+                setOpen(true);
+            } else closeMenu();
+        } catch  {
+            closeMenu();
+        }
+    }, [
+        closeMenu,
+        editor
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        let lastText = editor.getEditorState().read(()=>(0, external_lexical_namespaceObject.$getRoot)().getTextContent());
+        return (0, utils_namespaceObject.mergeRegister)(editor.registerUpdateListener(({ editorState })=>{
+            const currText = editorState.read(()=>(0, external_lexical_namespaceObject.$getRoot)().getTextContent());
+            const textChanged = currText !== lastText;
+            lastText = currText;
+            if (textChanged) dismissedTriggerRef.current = null;
+            editorState.read(()=>{
+                const selection = (0, external_lexical_namespaceObject.$getSelection)();
+                if (!selection || !(0, external_lexical_namespaceObject.$isRangeSelection)(selection) || !selection.isCollapsed()) return void closeMenu();
+                const anchorNode = selection.anchor.getNode();
+                if (!(0, external_lexical_namespaceObject.$isTextNode)(anchorNode)) return void closeMenu();
+                const textContent = anchorNode.getTextContent();
+                const trigger = findTrigger(textContent, selection.anchor.offset);
+                if (!trigger) return void closeMenu();
+                if ((0, autocomplete_segments_cjs_namespaceObject.shouldSuppressOpenForDismissed)({
+                    triggerIndex: trigger.triggerIndex,
+                    nodeKey: anchorNode.getKey()
+                }, dismissedTriggerRef.current)) return;
+                openPickerForTrigger(trigger, anchorNode.getKey());
+            });
+        }), editor.registerCommand(external_lexical_namespaceObject.KEY_ENTER_COMMAND, (event)=>{
+            if (!triggerInfoRef.current) return false;
+            if (commitTypedAsChip()) {
+                event?.preventDefault();
+                return true;
+            }
+            return false;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH), editor.registerCommand(external_lexical_namespaceObject.KEY_ESCAPE_COMMAND, ()=>{
+            if (!openRef.current && !triggerInfoRef.current) return false;
+            closeMenu(true);
+            return true;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH));
+    }, [
+        closeMenu,
+        commitTypedAsChip,
+        editor,
+        openPickerForTrigger
+    ]);
+    const handleVariablePickerSelect = (0, external_react_namespaceObject.useCallback)((path)=>{
+        const inferredType = (0, autocomplete_segments_cjs_namespaceObject.inferTokenTypeFromPath)(path, optionsRef.current);
+        commitChip({
+            type: inferredType,
+            value: path
+        });
+    }, [
+        commitChip
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(PromptEditorAutocompleteMenu_cjs_namespaceObject.PromptEditorAutocompleteMenu, {
+        open: open,
+        anchorEl: anchorEl,
+        initialSearch: query,
+        options: options,
+        onSelect: handleVariablePickerSelect,
+        onCommitFreeForm: handleVariablePickerSelect,
+        onClose: ()=>closeMenu(true)
+    });
+};
+exports.AutocompletePlugin = __webpack_exports__.AutocompletePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AutocompletePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/plugins/AutocompletePlugin.d.ts

@@ -0,0 +1,15 @@
+import type { PromptEditorAutoCompleteOption } from '../types';
+/**
+ * Drives the `$`-trigger flow: detects when the user has typed a `$` in a valid trigger context,
+ * opens `<VariablePickerAutocompleteMenu>` anchored to the caret, threads selection back into a
+ * Lexical token chip on commit, and handles dismissal (Escape, click-outside, scroll, free-form
+ * Enter on a typed-but-unmatched `$prefix.path`).
+ *
+ * The picker (a wrapper around the canvas-wide `VariablePicker`) owns search, drill-in, and
+ * keyboard navigation while it has focus. This plugin only handles the parts that have to live in
+ * the Lexical editor: trigger detection, dismissal sentinel, free-form Enter fallback after
+ * dismissal, and refocusing the editor when the picker closes.
+ */
+export declare const AutocompletePlugin: ({ options }: {
+    options: PromptEditorAutoCompleteOption[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/prompt-editor/plugins/AutocompletePlugin.js

@@ -0,0 +1,208 @@
+import { jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister } from "@lexical/utils";
+import { $createTextNode, $getRoot, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, getDOMSelectionFromTarget } from "lexical";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { PromptEditorAutocompleteMenu } from "../components/PromptEditorAutocompleteMenu.js";
+import { VARIABLE_PATH_REGEX, inferTokenTypeFromPath, shouldSuppressOpenForDismissed } from "../utils/autocomplete-segments.js";
+import { createTokenNodeForOption } from "../utils/insert-token.js";
+const findTrigger = (text, cursorPos)=>{
+    let triggerIndex = -1;
+    for(let i = cursorPos - 1; i >= 0; i--){
+        const char = text[i];
+        if (/\s/.test(char)) break;
+        if ('$' === char) {
+            if (0 === i || /\s/.test(text[i - 1])) triggerIndex = i;
+            break;
+        }
+    }
+    if (-1 === triggerIndex) return null;
+    return {
+        triggerIndex,
+        query: text.slice(triggerIndex + 1, cursorPos)
+    };
+};
+const getCaretRectForEditor = (editor)=>{
+    const rootElement = editor.getRootElement();
+    const fallbackRect = rootElement?.getBoundingClientRect() ?? new DOMRect();
+    const domSelection = getDOMSelectionFromTarget(rootElement);
+    if (!domSelection || 0 === domSelection.rangeCount) return fallbackRect;
+    const range = domSelection.getRangeAt(0).cloneRange();
+    range.collapse(false);
+    const rects = 'function' == typeof range.getClientRects ? range.getClientRects() : null;
+    const rect = rects?.item(0) ?? range.getBoundingClientRect();
+    if (!Number.isFinite(rect.x) || !Number.isFinite(rect.y)) return fallbackRect;
+    if (0 === rect.width && 0 === rect.height) return fallbackRect;
+    return rect;
+};
+const AutocompletePlugin = ({ options })=>{
+    const [editor] = useLexicalComposerContext();
+    const [open, setOpen] = useState(false);
+    const [anchorEl, setAnchorEl] = useState(null);
+    const [query, setQuery] = useState('');
+    const triggerInfoRef = useRef(null);
+    const dismissedTriggerRef = useRef(null);
+    const optionsRef = useRef(options);
+    const openRef = useRef(open);
+    useEffect(()=>{
+        optionsRef.current = options;
+        openRef.current = open;
+    });
+    const closeMenu = useCallback((explicit = false)=>{
+        const wasOpen = openRef.current;
+        if (explicit && triggerInfoRef.current) dismissedTriggerRef.current = {
+            ...triggerInfoRef.current
+        };
+        setOpen(false);
+        setAnchorEl(null);
+        if (!explicit) triggerInfoRef.current = null;
+        if (wasOpen) editor.focus();
+    }, [
+        editor
+    ]);
+    const commitChip = useCallback((option)=>{
+        const triggerInfo = triggerInfoRef.current;
+        if (!triggerInfo) return;
+        editor.update(()=>{
+            const selection = $getSelection();
+            if (!selection || !$isRangeSelection(selection)) return;
+            const anchorNode = selection.anchor.getNode();
+            if (!$isTextNode(anchorNode)) return;
+            if (anchorNode.getKey() !== triggerInfo.nodeKey) return;
+            const textContent = anchorNode.getTextContent();
+            const cursorOffset = selection.anchor.offset;
+            const textBefore = textContent.slice(0, triggerInfo.triggerIndex);
+            const textAfter = textContent.slice(cursorOffset);
+            const tokenNode = createTokenNodeForOption(option);
+            if (textBefore) {
+                anchorNode.setTextContent(textBefore);
+                anchorNode.insertAfter(tokenNode);
+            } else anchorNode.replace(tokenNode);
+            if (textAfter) {
+                const textAfterNode = $createTextNode(textAfter);
+                tokenNode.insertAfter(textAfterNode);
+                textAfterNode.select(0, 0);
+            } else tokenNode.selectNext(0, 0);
+        });
+        closeMenu();
+    }, [
+        closeMenu,
+        editor
+    ]);
+    const commitTypedAsChip = useCallback(()=>{
+        const triggerInfo = triggerInfoRef.current;
+        if (!triggerInfo) return false;
+        let committed = false;
+        editor.read(()=>{
+            const selection = $getSelection();
+            if (!selection || !$isRangeSelection(selection)) return;
+            const anchorNode = selection.anchor.getNode();
+            if (!$isTextNode(anchorNode)) return;
+            if (anchorNode.getKey() !== triggerInfo.nodeKey) return;
+            const textContent = anchorNode.getTextContent();
+            const cursorOffset = selection.anchor.offset;
+            const typedQuery = textContent.slice(triggerInfo.triggerIndex + 1, cursorOffset);
+            if (!VARIABLE_PATH_REGEX.test(typedQuery)) return;
+            const inferredType = inferTokenTypeFromPath(typedQuery, optionsRef.current);
+            committed = true;
+            queueMicrotask(()=>commitChip({
+                    type: inferredType,
+                    value: typedQuery
+                }));
+        });
+        return committed;
+    }, [
+        commitChip,
+        editor
+    ]);
+    const openPickerForTrigger = useCallback((trigger, anchorNodeKey)=>{
+        triggerInfoRef.current = {
+            triggerIndex: trigger.triggerIndex,
+            nodeKey: anchorNodeKey
+        };
+        setQuery(trigger.query);
+        try {
+            const domSelection = getDOMSelectionFromTarget(editor.getRootElement());
+            if (domSelection && domSelection.rangeCount > 0) {
+                const editorRoot = editor.getRootElement();
+                const caretRect = getCaretRectForEditor(editor);
+                const editorRect = editorRoot?.getBoundingClientRect() ?? new DOMRect();
+                const offsetTop = caretRect.top - editorRect.top;
+                const offsetLeft = caretRect.left - editorRect.left;
+                const caretWidth = caretRect.width;
+                const caretHeight = caretRect.height;
+                setAnchorEl({
+                    getBoundingClientRect: ()=>{
+                        const live = editorRoot?.getBoundingClientRect() ?? new DOMRect();
+                        return new DOMRect(live.left + offsetLeft, live.top + offsetTop, caretWidth, caretHeight);
+                    },
+                    contextElement: editorRoot ?? void 0
+                });
+                setOpen(true);
+            } else closeMenu();
+        } catch  {
+            closeMenu();
+        }
+    }, [
+        closeMenu,
+        editor
+    ]);
+    useEffect(()=>{
+        let lastText = editor.getEditorState().read(()=>$getRoot().getTextContent());
+        return mergeRegister(editor.registerUpdateListener(({ editorState })=>{
+            const currText = editorState.read(()=>$getRoot().getTextContent());
+            const textChanged = currText !== lastText;
+            lastText = currText;
+            if (textChanged) dismissedTriggerRef.current = null;
+            editorState.read(()=>{
+                const selection = $getSelection();
+                if (!selection || !$isRangeSelection(selection) || !selection.isCollapsed()) return void closeMenu();
+                const anchorNode = selection.anchor.getNode();
+                if (!$isTextNode(anchorNode)) return void closeMenu();
+                const textContent = anchorNode.getTextContent();
+                const trigger = findTrigger(textContent, selection.anchor.offset);
+                if (!trigger) return void closeMenu();
+                if (shouldSuppressOpenForDismissed({
+                    triggerIndex: trigger.triggerIndex,
+                    nodeKey: anchorNode.getKey()
+                }, dismissedTriggerRef.current)) return;
+                openPickerForTrigger(trigger, anchorNode.getKey());
+            });
+        }), editor.registerCommand(KEY_ENTER_COMMAND, (event)=>{
+            if (!triggerInfoRef.current) return false;
+            if (commitTypedAsChip()) {
+                event?.preventDefault();
+                return true;
+            }
+            return false;
+        }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ESCAPE_COMMAND, ()=>{
+            if (!openRef.current && !triggerInfoRef.current) return false;
+            closeMenu(true);
+            return true;
+        }, COMMAND_PRIORITY_HIGH));
+    }, [
+        closeMenu,
+        commitTypedAsChip,
+        editor,
+        openPickerForTrigger
+    ]);
+    const handleVariablePickerSelect = useCallback((path)=>{
+        const inferredType = inferTokenTypeFromPath(path, optionsRef.current);
+        commitChip({
+            type: inferredType,
+            value: path
+        });
+    }, [
+        commitChip
+    ]);
+    return /*#__PURE__*/ jsx(PromptEditorAutocompleteMenu, {
+        open: open,
+        anchorEl: anchorEl,
+        initialSearch: query,
+        options: options,
+        onSelect: handleVariablePickerSelect,
+        onCommitFreeForm: handleVariablePickerSelect,
+        onClose: ()=>closeMenu(true)
+    });
+};
+export { AutocompletePlugin };

package/dist/components/ui/prompt-editor/plugins/CopyPastePlugin.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CopyPastePlugin: ()=>CopyPastePlugin
+});
+const external_react_namespaceObject = require("react");
+const clipboard_namespaceObject = require("@lexical/clipboard");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const utils_namespaceObject = require("@lexical/utils");
+const external_lexical_namespaceObject = require("lexical");
+const index_cjs_namespaceObject = require("../nodes/index.cjs");
+const external_utils_index_cjs_namespaceObject = require("../utils/index.cjs");
+const LEXICAL_MIME = 'application/x-lexical-editor';
+const copySelectionToClipboard = (editor, clipboardData, selection)=>{
+    const tokens = (0, external_utils_index_cjs_namespaceObject.getEditorTokensFromSelection)(selection);
+    if (0 === tokens.length) return false;
+    clipboardData.setData('text/plain', (0, external_utils_index_cjs_namespaceObject.tokensToClipboardString)(tokens));
+    const lexicalJson = (0, clipboard_namespaceObject.$getLexicalContent)(editor, selection);
+    if (lexicalJson) clipboardData.setData(LEXICAL_MIME, lexicalJson);
+    return true;
+};
+const tryPasteLexicalContent = (editor, clipboardData, selection)=>{
+    const lexicalJson = clipboardData.getData(LEXICAL_MIME);
+    if (!lexicalJson) return false;
+    try {
+        const parsed = JSON.parse(lexicalJson);
+        if (!parsed.nodes || !Array.isArray(parsed.nodes)) return false;
+        const nodes = (0, clipboard_namespaceObject.$generateNodesFromSerializedNodes)(parsed.nodes);
+        if (0 === nodes.length) return false;
+        (0, clipboard_namespaceObject.$insertGeneratedNodes)(editor, nodes, selection);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const insertTokensAtSelection = (tokens, selection)=>{
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return;
+    if (!selection.isCollapsed()) selection.removeText();
+    for (const token of tokens)if ('text' === token.type) {
+        const lines = token.value.split('\n');
+        for(let i = 0; i < lines.length; i++){
+            if (lines[i]) selection.insertText(lines[i]);
+            if (i < lines.length - 1) selection.insertParagraph();
+        }
+    } else {
+        let tokenNode;
+        switch(token.type){
+            case 'input':
+                tokenNode = (0, index_cjs_namespaceObject.createInputTokenNode)(token.value);
+                break;
+            case 'output':
+                tokenNode = (0, index_cjs_namespaceObject.createOutputTokenNode)(token.value);
+                break;
+            case 'state':
+                tokenNode = (0, index_cjs_namespaceObject.createStateTokenNode)(token.value);
+                break;
+            case 'resource':
+                tokenNode = (0, index_cjs_namespaceObject.createResourceTokenNode)(token.value);
+                break;
+            default:
+                throw new Error('Unknown token type');
+        }
+        if (tokenNode) selection.insertNodes([
+            tokenNode
+        ]);
+    }
+};
+const pasteTextContent = (text, selection)=>{
+    if (!text) return false;
+    const tokens = (0, external_utils_index_cjs_namespaceObject.clipboardStringToTokens)(text);
+    if (0 === tokens.length) return false;
+    insertTokensAtSelection(tokens, selection);
+    return true;
+};
+const CopyPastePlugin = ()=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    (0, external_react_namespaceObject.useEffect)(()=>(0, utils_namespaceObject.mergeRegister)(editor.registerCommand(external_lexical_namespaceObject.COPY_COMMAND, (event)=>{
+            if (!event || !('clipboardData' in event) || !event.clipboardData) return false;
+            let handled = false;
+            editor.read(()=>{
+                let selection = (0, external_lexical_namespaceObject.$getSelection)();
+                if (!selection || (0, external_lexical_namespaceObject.$isRangeSelection)(selection) && selection.isCollapsed()) {
+                    const domSelection = window.getSelection();
+                    const rootElement = editor.getRootElement();
+                    if (domSelection && rootElement && !domSelection.isCollapsed) selection = (0, external_lexical_namespaceObject.$createRangeSelectionFromDom)(domSelection, editor);
+                }
+                if (!selection || (0, external_lexical_namespaceObject.$isRangeSelection)(selection) && selection.isCollapsed()) return;
+                handled = copySelectionToClipboard(editor, event.clipboardData, selection);
+            });
+            if (handled) event.preventDefault();
+            return handled;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_CRITICAL), editor.registerCommand(external_lexical_namespaceObject.CUT_COMMAND, (event)=>{
+            if (!event || !('clipboardData' in event) || !event.clipboardData) return false;
+            let handled = false;
+            editor.read(()=>{
+                let selection = (0, external_lexical_namespaceObject.$getSelection)();
+                if (!selection || (0, external_lexical_namespaceObject.$isRangeSelection)(selection) && selection.isCollapsed()) {
+                    const domSelection = window.getSelection();
+                    const rootElement = editor.getRootElement();
+                    if (domSelection && rootElement && !domSelection.isCollapsed) selection = (0, external_lexical_namespaceObject.$createRangeSelectionFromDom)(domSelection, editor);
+                }
+                if (!selection || (0, external_lexical_namespaceObject.$isRangeSelection)(selection) && selection.isCollapsed()) return;
+                handled = copySelectionToClipboard(editor, event.clipboardData, selection);
+            });
+            if (handled) {
+                event.preventDefault();
+                editor.update(()=>{
+                    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+                    if (selection && (0, external_lexical_namespaceObject.$isRangeSelection)(selection)) selection.removeText();
+                });
+            }
+            return handled;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_CRITICAL), editor.registerCommand(external_lexical_namespaceObject.PASTE_COMMAND, (event)=>{
+            if (!event || !('clipboardData' in event) || !event.clipboardData) return false;
+            const clipboardData = event.clipboardData;
+            const hasLexicalJson = Boolean(clipboardData.getData(LEXICAL_MIME));
+            const plainText = clipboardData.getData('text/plain');
+            const hasPlainText = Boolean(plainText);
+            if (!hasLexicalJson && !hasPlainText) return false;
+            event.preventDefault();
+            editor.update(()=>{
+                const selection = (0, external_lexical_namespaceObject.$getSelection)();
+                if (!selection) return;
+                if (hasLexicalJson && tryPasteLexicalContent(editor, clipboardData, selection)) return;
+                if (hasPlainText) pasteTextContent(plainText, selection);
+            }, {
+                discrete: true
+            });
+            return true;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_CRITICAL)), [
+        editor
+    ]);
+    return null;
+};
+exports.CopyPastePlugin = __webpack_exports__.CopyPastePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CopyPastePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/plugins/CopyPastePlugin.d.ts

@@ -0,0 +1 @@
+export declare const CopyPastePlugin: () => null;