@uipath/apollo-wind 2.22.0 → 2.24.0

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

@@ -0,0 +1,186 @@
+"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__, {
+    RenameTokensPlugin: ()=>RenameTokensPlugin
+});
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../nodes/index.cjs");
+const external_utils_index_cjs_namespaceObject = require("../utils/index.cjs");
+const token_nodes_cjs_namespaceObject = require("./shared/token-nodes.cjs");
+const TOKEN_TYPES = [
+    'input',
+    'state',
+    'output',
+    'resource'
+];
+const createTreeNode = ()=>({
+        children: new Map()
+    });
+const buildPathTree = (paths)=>{
+    const root = createTreeNode();
+    for (const path of paths){
+        if (!path) continue;
+        const segments = path.split('.').filter(Boolean);
+        if (0 === segments.length) continue;
+        let current = root;
+        for (const segment of segments){
+            const next = current.children.get(segment) ?? createTreeNode();
+            if (!current.children.has(segment)) current.children.set(segment, next);
+            current = next;
+        }
+    }
+    return root;
+};
+const joinPath = (prefix, key)=>prefix ? `${prefix}.${key}` : key;
+const detectPathRenames = (prevNode, nextNode, prevPrefix, nextPrefix, renames)=>{
+    const prevKeys = [
+        ...prevNode.children.keys()
+    ];
+    const nextKeys = [
+        ...nextNode.children.keys()
+    ];
+    const removedKeys = prevKeys.filter((k)=>!nextNode.children.has(k));
+    const addedKeys = nextKeys.filter((k)=>!prevNode.children.has(k));
+    const commonKeys = prevKeys.filter((k)=>nextNode.children.has(k));
+    if (1 === removedKeys.length && 1 === addedKeys.length) {
+        const oldPath = joinPath(prevPrefix, removedKeys[0]);
+        const newPath = joinPath(nextPrefix, addedKeys[0]);
+        renames.push({
+            oldPath,
+            newPath
+        });
+        const prevChild = prevNode.children.get(removedKeys[0]);
+        const nextChild = nextNode.children.get(addedKeys[0]);
+        if (prevChild && nextChild) detectPathRenames(prevChild, nextChild, oldPath, newPath, renames);
+    }
+    for (const key of commonKeys){
+        const prevChild = prevNode.children.get(key);
+        const nextChild = nextNode.children.get(key);
+        if (prevChild && nextChild) detectPathRenames(prevChild, nextChild, joinPath(prevPrefix, key), joinPath(nextPrefix, key), renames);
+    }
+};
+const groupOptionsByType = (options)=>{
+    const grouped = {
+        input: new Set(),
+        state: new Set(),
+        output: new Set(),
+        resource: new Set()
+    };
+    for (const opt of options)grouped[opt.type].add(opt.value);
+    return grouped;
+};
+const detectRenamesByType = (prevOptions, currOptions)=>{
+    const prevGrouped = groupOptionsByType(prevOptions);
+    const currGrouped = groupOptionsByType(currOptions);
+    const renames = [];
+    for (const type of TOKEN_TYPES){
+        const typeRenames = [];
+        detectPathRenames(buildPathTree(prevGrouped[type]), buildPathTree(currGrouped[type]), '', '', typeRenames);
+        for (const rename of typeRenames)renames.push({
+            ...rename,
+            type
+        });
+    }
+    return renames;
+};
+const applyPathRename = (value, oldPath, newPath)=>{
+    if (value === oldPath) return newPath;
+    if (value.startsWith(`${oldPath}.`)) return `${newPath}${value.slice(oldPath.length)}`;
+    return value;
+};
+const RenameTokensPlugin = ({ options, onChange })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const prevOptionsRef = (0, external_react_namespaceObject.useRef)(options);
+    const renameSequenceRef = (0, external_react_namespaceObject.useRef)(0);
+    const onChangeRef = (0, external_react_namespaceObject.useRef)(onChange);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        onChangeRef.current = onChange;
+    }, [
+        onChange
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const prevOptions = prevOptionsRef.current;
+        prevOptionsRef.current = options;
+        const renames = detectRenamesByType(prevOptions, options);
+        if (0 === renames.length) return;
+        const sortedRenames = [
+            ...renames
+        ].sort((a, b)=>b.oldPath.length - a.oldPath.length);
+        const renameSequence = ++renameSequenceRef.current;
+        let cancelled = false;
+        queueMicrotask(()=>{
+            if (cancelled || renameSequenceRef.current !== renameSequence) return;
+            let updatedTokens = null;
+            editor.update(()=>{
+                let tokensChanged = false;
+                const tokenNodes = (0, token_nodes_cjs_namespaceObject.getAllPromptTokenNodes)();
+                const renamesByType = new Map();
+                for (const rename of sortedRenames){
+                    const list = renamesByType.get(rename.type);
+                    if (list) list.push(rename);
+                    else renamesByType.set(rename.type, [
+                        rename
+                    ]);
+                }
+                for (const node of tokenNodes){
+                    const nodeType = (0, index_cjs_namespaceObject.isInputTokenNode)(node) ? 'input' : (0, index_cjs_namespaceObject.isOutputTokenNode)(node) ? 'output' : (0, index_cjs_namespaceObject.isStateTokenNode)(node) ? 'state' : (0, index_cjs_namespaceObject.isResourceTokenNode)(node) ? 'resource' : null;
+                    if (!nodeType) continue;
+                    const matchingRenames = renamesByType.get(nodeType);
+                    if (!matchingRenames) continue;
+                    const currentValue = node.getValue();
+                    let nextValue = currentValue;
+                    for (const rename of matchingRenames)nextValue = applyPathRename(nextValue, rename.oldPath, rename.newPath);
+                    if (nextValue !== currentValue) {
+                        node.setValue(nextValue);
+                        tokensChanged = true;
+                    }
+                }
+                if (tokensChanged) updatedTokens = (0, external_utils_index_cjs_namespaceObject.$getEditorTokensInternal)();
+            }, {
+                discrete: true,
+                onUpdate: ()=>{
+                    if (cancelled || renameSequenceRef.current !== renameSequence) return;
+                    if (updatedTokens) onChangeRef.current?.(updatedTokens);
+                }
+            });
+        });
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        editor,
+        options
+    ]);
+    return null;
+};
+exports.RenameTokensPlugin = __webpack_exports__.RenameTokensPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RenameTokensPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,7 @@
+import type { PromptEditorAutoCompleteOption, PromptEditorToken } from '../types';
+interface RenameTokensPluginProps {
+    options: PromptEditorAutoCompleteOption[];
+    onChange?: (tokens: PromptEditorToken[]) => void;
+}
+export declare const RenameTokensPlugin: ({ options, onChange }: RenameTokensPluginProps) => null;
+export {};

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

@@ -0,0 +1,152 @@
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { useEffect, useRef } from "react";
+import { isInputTokenNode, isOutputTokenNode, isResourceTokenNode, isStateTokenNode } from "../nodes/index.js";
+import { $getEditorTokensInternal } from "../utils/index.js";
+import { getAllPromptTokenNodes } from "./shared/token-nodes.js";
+const TOKEN_TYPES = [
+    'input',
+    'state',
+    'output',
+    'resource'
+];
+const createTreeNode = ()=>({
+        children: new Map()
+    });
+const buildPathTree = (paths)=>{
+    const root = createTreeNode();
+    for (const path of paths){
+        if (!path) continue;
+        const segments = path.split('.').filter(Boolean);
+        if (0 === segments.length) continue;
+        let current = root;
+        for (const segment of segments){
+            const next = current.children.get(segment) ?? createTreeNode();
+            if (!current.children.has(segment)) current.children.set(segment, next);
+            current = next;
+        }
+    }
+    return root;
+};
+const joinPath = (prefix, key)=>prefix ? `${prefix}.${key}` : key;
+const detectPathRenames = (prevNode, nextNode, prevPrefix, nextPrefix, renames)=>{
+    const prevKeys = [
+        ...prevNode.children.keys()
+    ];
+    const nextKeys = [
+        ...nextNode.children.keys()
+    ];
+    const removedKeys = prevKeys.filter((k)=>!nextNode.children.has(k));
+    const addedKeys = nextKeys.filter((k)=>!prevNode.children.has(k));
+    const commonKeys = prevKeys.filter((k)=>nextNode.children.has(k));
+    if (1 === removedKeys.length && 1 === addedKeys.length) {
+        const oldPath = joinPath(prevPrefix, removedKeys[0]);
+        const newPath = joinPath(nextPrefix, addedKeys[0]);
+        renames.push({
+            oldPath,
+            newPath
+        });
+        const prevChild = prevNode.children.get(removedKeys[0]);
+        const nextChild = nextNode.children.get(addedKeys[0]);
+        if (prevChild && nextChild) detectPathRenames(prevChild, nextChild, oldPath, newPath, renames);
+    }
+    for (const key of commonKeys){
+        const prevChild = prevNode.children.get(key);
+        const nextChild = nextNode.children.get(key);
+        if (prevChild && nextChild) detectPathRenames(prevChild, nextChild, joinPath(prevPrefix, key), joinPath(nextPrefix, key), renames);
+    }
+};
+const groupOptionsByType = (options)=>{
+    const grouped = {
+        input: new Set(),
+        state: new Set(),
+        output: new Set(),
+        resource: new Set()
+    };
+    for (const opt of options)grouped[opt.type].add(opt.value);
+    return grouped;
+};
+const detectRenamesByType = (prevOptions, currOptions)=>{
+    const prevGrouped = groupOptionsByType(prevOptions);
+    const currGrouped = groupOptionsByType(currOptions);
+    const renames = [];
+    for (const type of TOKEN_TYPES){
+        const typeRenames = [];
+        detectPathRenames(buildPathTree(prevGrouped[type]), buildPathTree(currGrouped[type]), '', '', typeRenames);
+        for (const rename of typeRenames)renames.push({
+            ...rename,
+            type
+        });
+    }
+    return renames;
+};
+const applyPathRename = (value, oldPath, newPath)=>{
+    if (value === oldPath) return newPath;
+    if (value.startsWith(`${oldPath}.`)) return `${newPath}${value.slice(oldPath.length)}`;
+    return value;
+};
+const RenameTokensPlugin = ({ options, onChange })=>{
+    const [editor] = useLexicalComposerContext();
+    const prevOptionsRef = useRef(options);
+    const renameSequenceRef = useRef(0);
+    const onChangeRef = useRef(onChange);
+    useEffect(()=>{
+        onChangeRef.current = onChange;
+    }, [
+        onChange
+    ]);
+    useEffect(()=>{
+        const prevOptions = prevOptionsRef.current;
+        prevOptionsRef.current = options;
+        const renames = detectRenamesByType(prevOptions, options);
+        if (0 === renames.length) return;
+        const sortedRenames = [
+            ...renames
+        ].sort((a, b)=>b.oldPath.length - a.oldPath.length);
+        const renameSequence = ++renameSequenceRef.current;
+        let cancelled = false;
+        queueMicrotask(()=>{
+            if (cancelled || renameSequenceRef.current !== renameSequence) return;
+            let updatedTokens = null;
+            editor.update(()=>{
+                let tokensChanged = false;
+                const tokenNodes = getAllPromptTokenNodes();
+                const renamesByType = new Map();
+                for (const rename of sortedRenames){
+                    const list = renamesByType.get(rename.type);
+                    if (list) list.push(rename);
+                    else renamesByType.set(rename.type, [
+                        rename
+                    ]);
+                }
+                for (const node of tokenNodes){
+                    const nodeType = isInputTokenNode(node) ? 'input' : isOutputTokenNode(node) ? 'output' : isStateTokenNode(node) ? 'state' : isResourceTokenNode(node) ? 'resource' : null;
+                    if (!nodeType) continue;
+                    const matchingRenames = renamesByType.get(nodeType);
+                    if (!matchingRenames) continue;
+                    const currentValue = node.getValue();
+                    let nextValue = currentValue;
+                    for (const rename of matchingRenames)nextValue = applyPathRename(nextValue, rename.oldPath, rename.newPath);
+                    if (nextValue !== currentValue) {
+                        node.setValue(nextValue);
+                        tokensChanged = true;
+                    }
+                }
+                if (tokensChanged) updatedTokens = $getEditorTokensInternal();
+            }, {
+                discrete: true,
+                onUpdate: ()=>{
+                    if (cancelled || renameSequenceRef.current !== renameSequence) return;
+                    if (updatedTokens) onChangeRef.current?.(updatedTokens);
+                }
+            });
+        });
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        editor,
+        options
+    ]);
+    return null;
+};
+export { RenameTokensPlugin };

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

@@ -0,0 +1,132 @@
+"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__, {
+    ToolbarActionsPlugin: ()=>ToolbarActionsPlugin
+});
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_lexical_namespaceObject = require("lexical");
+const external_react_namespaceObject = require("react");
+const wrapSelectionWithMarkers = (startMarker, endMarker)=>{
+    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return;
+    if (selection.isCollapsed()) {
+        const markerNode = (0, external_lexical_namespaceObject.$createTextNode)(`${startMarker}${endMarker}`);
+        selection.insertNodes([
+            markerNode
+        ]);
+        const offset = startMarker.length;
+        selection.setTextNodeRange(markerNode, offset, markerNode, offset);
+        return;
+    }
+    const isBackward = selection.isBackward();
+    const startPoint = isBackward ? selection.focus : selection.anchor;
+    const endPoint = isBackward ? selection.anchor : selection.focus;
+    const startNode = startPoint.getNode();
+    const startOffset = startPoint.offset;
+    const endNode = endPoint.getNode();
+    const endOffset = endPoint.offset;
+    if ((0, external_lexical_namespaceObject.$isTextNode)(endNode)) {
+        const text = endNode.getTextContent();
+        endNode.setTextContent(text.slice(0, endOffset) + endMarker + text.slice(endOffset));
+    } else {
+        const endText = (0, external_lexical_namespaceObject.$createTextNode)(endMarker);
+        endNode.insertAfter(endText);
+    }
+    if ((0, external_lexical_namespaceObject.$isTextNode)(startNode)) {
+        const text = startNode.getTextContent();
+        startNode.setTextContent(text.slice(0, startOffset) + startMarker + text.slice(startOffset));
+    } else {
+        const startText = (0, external_lexical_namespaceObject.$createTextNode)(startMarker);
+        startNode.insertBefore(startText);
+    }
+};
+const insertLinePrefixForSelection = (getPrefix)=>{
+    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return;
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    const anchorParent = (0, external_lexical_namespaceObject.$isTextNode)(anchorNode) || !(0, external_lexical_namespaceObject.$isParagraphNode)(anchorNode) ? anchorNode.getParent() : anchorNode;
+    const focusParent = (0, external_lexical_namespaceObject.$isTextNode)(focusNode) || !(0, external_lexical_namespaceObject.$isParagraphNode)(focusNode) ? focusNode.getParent() : focusNode;
+    if (!anchorParent || !focusParent) return;
+    const root = (0, external_lexical_namespaceObject.$getRoot)();
+    const allParagraphs = root.getChildren().filter(external_lexical_namespaceObject.$isParagraphNode);
+    const anchorIndex = allParagraphs.findIndex((p)=>p.is(anchorParent));
+    const focusIndex = allParagraphs.findIndex((p)=>p.is(focusParent));
+    if (-1 === anchorIndex || -1 === focusIndex) return;
+    const startIndex = Math.min(anchorIndex, focusIndex);
+    const endIndex = Math.max(anchorIndex, focusIndex);
+    let lineCounter = 0;
+    for(let i = startIndex; i <= endIndex; i++){
+        const paragraph = allParagraphs[i];
+        const firstChild = paragraph.getFirstChild();
+        const prefix = getPrefix(lineCounter);
+        lineCounter++;
+        if ((0, external_lexical_namespaceObject.$isTextNode)(firstChild)) {
+            const text = firstChild.getTextContent();
+            if (text.startsWith(prefix)) firstChild.setTextContent(text.slice(prefix.length));
+            else firstChild.setTextContent(prefix + text);
+        } else if (firstChild) {
+            const prefixNode = (0, external_lexical_namespaceObject.$createTextNode)(prefix);
+            firstChild.insertBefore(prefixNode);
+        } else paragraph.append((0, external_lexical_namespaceObject.$createTextNode)(prefix));
+    }
+};
+const ToolbarActionsPlugin = ({ actionsRef })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        actionsRef.current = {
+            formatBold: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('**', '**'));
+            },
+            formatItalic: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('*', '*'));
+            },
+            formatStrikethrough: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('~~', '~~'));
+            },
+            formatNumberedList: ()=>{
+                editor.update(()=>insertLinePrefixForSelection((i)=>`${i + 1}. `));
+            },
+            formatBulletedList: ()=>{
+                editor.update(()=>insertLinePrefixForSelection(()=>'- '));
+            }
+        };
+        return ()=>{
+            actionsRef.current = null;
+        };
+    }, [
+        editor,
+        actionsRef
+    ]);
+    return null;
+};
+exports.ToolbarActionsPlugin = __webpack_exports__.ToolbarActionsPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ToolbarActionsPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,7 @@
+import { type MutableRefObject } from 'react';
+import type { PromptEditorToolbarActionsRef } from '../types';
+interface ToolbarActionsPluginProps {
+    actionsRef: MutableRefObject<PromptEditorToolbarActionsRef | null>;
+}
+export declare const ToolbarActionsPlugin: ({ actionsRef }: ToolbarActionsPluginProps) => null;
+export {};

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

@@ -0,0 +1,98 @@
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $createTextNode, $getRoot, $getSelection, $isParagraphNode, $isRangeSelection, $isTextNode } from "lexical";
+import { useEffect } from "react";
+const wrapSelectionWithMarkers = (startMarker, endMarker)=>{
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) return;
+    if (selection.isCollapsed()) {
+        const markerNode = $createTextNode(`${startMarker}${endMarker}`);
+        selection.insertNodes([
+            markerNode
+        ]);
+        const offset = startMarker.length;
+        selection.setTextNodeRange(markerNode, offset, markerNode, offset);
+        return;
+    }
+    const isBackward = selection.isBackward();
+    const startPoint = isBackward ? selection.focus : selection.anchor;
+    const endPoint = isBackward ? selection.anchor : selection.focus;
+    const startNode = startPoint.getNode();
+    const startOffset = startPoint.offset;
+    const endNode = endPoint.getNode();
+    const endOffset = endPoint.offset;
+    if ($isTextNode(endNode)) {
+        const text = endNode.getTextContent();
+        endNode.setTextContent(text.slice(0, endOffset) + endMarker + text.slice(endOffset));
+    } else {
+        const endText = $createTextNode(endMarker);
+        endNode.insertAfter(endText);
+    }
+    if ($isTextNode(startNode)) {
+        const text = startNode.getTextContent();
+        startNode.setTextContent(text.slice(0, startOffset) + startMarker + text.slice(startOffset));
+    } else {
+        const startText = $createTextNode(startMarker);
+        startNode.insertBefore(startText);
+    }
+};
+const insertLinePrefixForSelection = (getPrefix)=>{
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) return;
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    const anchorParent = $isTextNode(anchorNode) || !$isParagraphNode(anchorNode) ? anchorNode.getParent() : anchorNode;
+    const focusParent = $isTextNode(focusNode) || !$isParagraphNode(focusNode) ? focusNode.getParent() : focusNode;
+    if (!anchorParent || !focusParent) return;
+    const root = $getRoot();
+    const allParagraphs = root.getChildren().filter($isParagraphNode);
+    const anchorIndex = allParagraphs.findIndex((p)=>p.is(anchorParent));
+    const focusIndex = allParagraphs.findIndex((p)=>p.is(focusParent));
+    if (-1 === anchorIndex || -1 === focusIndex) return;
+    const startIndex = Math.min(anchorIndex, focusIndex);
+    const endIndex = Math.max(anchorIndex, focusIndex);
+    let lineCounter = 0;
+    for(let i = startIndex; i <= endIndex; i++){
+        const paragraph = allParagraphs[i];
+        const firstChild = paragraph.getFirstChild();
+        const prefix = getPrefix(lineCounter);
+        lineCounter++;
+        if ($isTextNode(firstChild)) {
+            const text = firstChild.getTextContent();
+            if (text.startsWith(prefix)) firstChild.setTextContent(text.slice(prefix.length));
+            else firstChild.setTextContent(prefix + text);
+        } else if (firstChild) {
+            const prefixNode = $createTextNode(prefix);
+            firstChild.insertBefore(prefixNode);
+        } else paragraph.append($createTextNode(prefix));
+    }
+};
+const ToolbarActionsPlugin = ({ actionsRef })=>{
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>{
+        actionsRef.current = {
+            formatBold: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('**', '**'));
+            },
+            formatItalic: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('*', '*'));
+            },
+            formatStrikethrough: ()=>{
+                editor.update(()=>wrapSelectionWithMarkers('~~', '~~'));
+            },
+            formatNumberedList: ()=>{
+                editor.update(()=>insertLinePrefixForSelection((i)=>`${i + 1}. `));
+            },
+            formatBulletedList: ()=>{
+                editor.update(()=>insertLinePrefixForSelection(()=>'- '));
+            }
+        };
+        return ()=>{
+            actionsRef.current = null;
+        };
+    }, [
+        editor,
+        actionsRef
+    ]);
+    return null;
+};
+export { ToolbarActionsPlugin };

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

@@ -0,0 +1,85 @@
+"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__, {
+    ValidateTokensPlugin: ()=>ValidateTokensPlugin
+});
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_react_namespaceObject = require("react");
+const token_nodes_cjs_namespaceObject = require("./shared/token-nodes.cjs");
+const NODE_TYPE_TO_TOKEN_TYPE = {
+    'input-token': 'input',
+    'output-token': 'output',
+    'state-token': 'state',
+    'resource-token': 'resource'
+};
+const ValidateTokensPlugin = ({ options })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const validValues = new Map();
+        for (const opt of options){
+            if (!validValues.has(opt.type)) validValues.set(opt.type, new Set());
+            validValues.get(opt.type).add(opt.value);
+        }
+        const checkIsInvalid = (node)=>{
+            const tokenType = NODE_TYPE_TO_TOKEN_TYPE[node.getType()];
+            if (!tokenType) return false;
+            const validSet = validValues.get(tokenType);
+            return !validSet || !validSet.has(node.getValue());
+        };
+        const validateAllNodes = ()=>{
+            const tokenNodes = (0, token_nodes_cjs_namespaceObject.getAllPromptTokenNodes)();
+            for (const node of tokenNodes){
+                const isInvalid = checkIsInvalid(node);
+                if (node.getIsInvalid() !== isInvalid) node.setIsInvalid(isInvalid);
+            }
+        };
+        editor.update(validateAllNodes);
+        const unregister = editor.registerUpdateListener(({ editorState, prevEditorState })=>{
+            if (editorState === prevEditorState) return;
+            editorState.read(()=>{
+                const tokenNodes = (0, token_nodes_cjs_namespaceObject.getAllPromptTokenNodes)();
+                let needsUpdate = false;
+                for (const node of tokenNodes)if (node.getIsInvalid() !== checkIsInvalid(node)) {
+                    needsUpdate = true;
+                    break;
+                }
+                if (needsUpdate) editor.update(validateAllNodes);
+            });
+        });
+        return unregister;
+    }, [
+        editor,
+        options
+    ]);
+    return null;
+};
+exports.ValidateTokensPlugin = __webpack_exports__.ValidateTokensPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ValidateTokensPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,4 @@
+import type { PromptEditorAutoCompleteOption } from '../types';
+export declare const ValidateTokensPlugin: ({ options, }: {
+    options: PromptEditorAutoCompleteOption[];
+}) => null;