@uipath/apollo-wind 2.23.0 → 2.24.0

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

@@ -0,0 +1,51 @@
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { useEffect } from "react";
+import { getAllPromptTokenNodes } from "./shared/token-nodes.js";
+const NODE_TYPE_TO_TOKEN_TYPE = {
+    'input-token': 'input',
+    'output-token': 'output',
+    'state-token': 'state',
+    'resource-token': 'resource'
+};
+const ValidateTokensPlugin = ({ options })=>{
+    const [editor] = useLexicalComposerContext();
+    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 = 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 = 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;
+};
+export { ValidateTokensPlugin };

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

@@ -0,0 +1,98 @@
+"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__, {
+    ValueSyncPlugin: ()=>ValueSyncPlugin
+});
+const external_react_namespaceObject = require("react");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_lexical_namespaceObject = require("lexical");
+const index_cjs_namespaceObject = require("../utils/index.cjs");
+const getDeepActiveElement = (rootElement)=>{
+    const rootNode = rootElement.getRootNode();
+    let activeElement = null;
+    activeElement = rootNode instanceof ShadowRoot || rootNode instanceof Document ? rootNode.activeElement : document.activeElement;
+    while(activeElement instanceof HTMLElement && activeElement.shadowRoot?.activeElement)activeElement = activeElement.shadowRoot.activeElement;
+    return activeElement;
+};
+const isEditorFocused = (rootElement)=>{
+    if (!rootElement) return false;
+    const activeElement = getDeepActiveElement(rootElement);
+    return !!activeElement && (activeElement === rootElement || rootElement.contains(activeElement));
+};
+const ValueSyncPlugin = ({ value, editorRef, lastEmittedValueRef, isSyncingRef })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const lastValueRef = (0, external_react_namespaceObject.useRef)(value);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (void 0 === value) return;
+        if (value === lastValueRef.current) return;
+        if (lastValueRef.current && (0, index_cjs_namespaceObject.areTokensEqual)(lastValueRef.current, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        if (lastEmittedValueRef?.current && (0, index_cjs_namespaceObject.areTokensEqual)(lastEmittedValueRef.current, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        const currentTokens = editorRef.current?.getEditorState().read(index_cjs_namespaceObject.$getEditorTokensInternal);
+        if (currentTokens && (0, index_cjs_namespaceObject.areTokensEqual)(currentTokens, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        const rootElement = editor.getRootElement();
+        const editorIsFocused = isEditorFocused(rootElement);
+        const shouldSkipDomSelection = !editorIsFocused;
+        try {
+            if (isSyncingRef) isSyncingRef.current = true;
+            editor.update(()=>{
+                if (shouldSkipDomSelection) (0, external_lexical_namespaceObject.$addUpdateTag)(external_lexical_namespaceObject.SKIP_DOM_SELECTION_TAG);
+                (0, index_cjs_namespaceObject.$setEditorTokensInternal)(value);
+            }, {
+                discrete: true,
+                onUpdate: ()=>{
+                    if (isSyncingRef) isSyncingRef.current = false;
+                }
+            });
+            lastValueRef.current = value;
+        } catch (error) {
+            if (isSyncingRef) isSyncingRef.current = false;
+            console.error('ValueSyncPlugin: Error syncing value to editor', error);
+        }
+    }, [
+        editor,
+        value,
+        editorRef,
+        lastEmittedValueRef,
+        isSyncingRef
+    ]);
+    return null;
+};
+exports.ValueSyncPlugin = __webpack_exports__.ValueSyncPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ValueSyncPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,8 @@
+import { type LexicalEditor } from 'lexical';
+import type { PromptEditorToken } from '../types';
+export declare const ValueSyncPlugin: ({ value, editorRef, lastEmittedValueRef, isSyncingRef, }: {
+    value: PromptEditorToken[] | undefined;
+    editorRef: React.MutableRefObject<LexicalEditor | null>;
+    lastEmittedValueRef?: React.MutableRefObject<PromptEditorToken[] | null>;
+    isSyncingRef?: React.MutableRefObject<boolean>;
+}) => null;

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

@@ -0,0 +1,64 @@
+import { useEffect, useRef } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $addUpdateTag, SKIP_DOM_SELECTION_TAG } from "lexical";
+import { $getEditorTokensInternal, $setEditorTokensInternal, areTokensEqual } from "../utils/index.js";
+const getDeepActiveElement = (rootElement)=>{
+    const rootNode = rootElement.getRootNode();
+    let activeElement = null;
+    activeElement = rootNode instanceof ShadowRoot || rootNode instanceof Document ? rootNode.activeElement : document.activeElement;
+    while(activeElement instanceof HTMLElement && activeElement.shadowRoot?.activeElement)activeElement = activeElement.shadowRoot.activeElement;
+    return activeElement;
+};
+const isEditorFocused = (rootElement)=>{
+    if (!rootElement) return false;
+    const activeElement = getDeepActiveElement(rootElement);
+    return !!activeElement && (activeElement === rootElement || rootElement.contains(activeElement));
+};
+const ValueSyncPlugin = ({ value, editorRef, lastEmittedValueRef, isSyncingRef })=>{
+    const [editor] = useLexicalComposerContext();
+    const lastValueRef = useRef(value);
+    useEffect(()=>{
+        if (void 0 === value) return;
+        if (value === lastValueRef.current) return;
+        if (lastValueRef.current && areTokensEqual(lastValueRef.current, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        if (lastEmittedValueRef?.current && areTokensEqual(lastEmittedValueRef.current, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        const currentTokens = editorRef.current?.getEditorState().read($getEditorTokensInternal);
+        if (currentTokens && areTokensEqual(currentTokens, value)) {
+            lastValueRef.current = value;
+            return;
+        }
+        const rootElement = editor.getRootElement();
+        const editorIsFocused = isEditorFocused(rootElement);
+        const shouldSkipDomSelection = !editorIsFocused;
+        try {
+            if (isSyncingRef) isSyncingRef.current = true;
+            editor.update(()=>{
+                if (shouldSkipDomSelection) $addUpdateTag(SKIP_DOM_SELECTION_TAG);
+                $setEditorTokensInternal(value);
+            }, {
+                discrete: true,
+                onUpdate: ()=>{
+                    if (isSyncingRef) isSyncingRef.current = false;
+                }
+            });
+            lastValueRef.current = value;
+        } catch (error) {
+            if (isSyncingRef) isSyncingRef.current = false;
+            console.error('ValueSyncPlugin: Error syncing value to editor', error);
+        }
+    }, [
+        editor,
+        value,
+        editorRef,
+        lastEmittedValueRef,
+        isSyncingRef
+    ]);
+    return null;
+};
+export { ValueSyncPlugin };

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

@@ -0,0 +1,137 @@
+"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__, {
+    VARIABLE_DRAG_MIME: ()=>VARIABLE_DRAG_MIME,
+    VariableDropPlugin: ()=>VariableDropPlugin
+});
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_lexical_namespaceObject = require("lexical");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../utils/index.cjs");
+const VARIABLE_DRAG_MIME = 'application/x-apollo-prompt-variable';
+const getCaretFromPoint = (x, y)=>{
+    if (document.caretPositionFromPoint) {
+        const pos = document.caretPositionFromPoint(x, y);
+        return pos ? {
+            offsetNode: pos.offsetNode,
+            offset: pos.offset
+        } : null;
+    }
+    const range = document.caretRangeFromPoint?.(x, y);
+    return range ? {
+        offsetNode: range.startContainer,
+        offset: range.startOffset
+    } : null;
+};
+const $resolveDropPosition = (editor, offsetNode, domOffset, clientX)=>{
+    const node = (0, external_lexical_namespaceObject.$getNearestNodeFromDOMNode)(offsetNode);
+    if (!node) return null;
+    if ((0, external_lexical_namespaceObject.$isDecoratorNode)(node)) {
+        const el = editor.getElementByKey(node.getKey());
+        const rect = el?.getBoundingClientRect();
+        const isAfter = rect ? clientX > rect.left + rect.width / 2 : true;
+        const parent = node.getParent();
+        if (!parent) return null;
+        return {
+            key: parent.getKey(),
+            offset: node.getIndexWithinParent() + (isAfter ? 1 : 0),
+            type: 'element'
+        };
+    }
+    if ((0, external_lexical_namespaceObject.$isTextNode)(node)) return {
+        key: node.getKey(),
+        offset: domOffset,
+        type: 'text'
+    };
+    if ((0, external_lexical_namespaceObject.$isParagraphNode)(node)) return {
+        key: node.getKey(),
+        offset: domOffset,
+        type: 'element'
+    };
+    return null;
+};
+function VariableDropPlugin({ disabled, mapVarDropToToken }) {
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const mapRef = (0, external_react_namespaceObject.useRef)(mapVarDropToToken);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        mapRef.current = mapVarDropToToken;
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (disabled) return;
+        const hasVariablePayload = (dt)=>!!dt && dt.types.includes(VARIABLE_DRAG_MIME);
+        const onDragOver = (e)=>{
+            if (!hasVariablePayload(e.dataTransfer)) return;
+            e.preventDefault();
+            if (e.dataTransfer) e.dataTransfer.dropEffect = 'copy';
+        };
+        const onDrop = (e)=>{
+            const path = e.dataTransfer?.getData(VARIABLE_DRAG_MIME);
+            if (!path) return;
+            e.preventDefault();
+            const root = editor.getRootElement();
+            const caret = getCaretFromPoint(e.clientX, e.clientY);
+            editor.update(()=>{
+                let placed = false;
+                if (caret && root?.contains(caret.offsetNode)) {
+                    const resolved = $resolveDropPosition(editor, caret.offsetNode, caret.offset, e.clientX);
+                    if (resolved) {
+                        const sel = (0, external_lexical_namespaceObject.$createRangeSelection)();
+                        sel.anchor.set(resolved.key, resolved.offset, resolved.type);
+                        sel.focus.set(resolved.key, resolved.offset, resolved.type);
+                        (0, external_lexical_namespaceObject.$setSelection)(sel);
+                        placed = true;
+                    }
+                }
+                if (!placed) (0, external_lexical_namespaceObject.$getRoot)().selectEnd();
+                (0, index_cjs_namespaceObject.$insertTokenAtCursor)(mapRef.current(path));
+            });
+            editor.focus();
+        };
+        return editor.registerRootListener((rootElement, prevRootElement)=>{
+            if (prevRootElement) {
+                prevRootElement.removeEventListener('dragover', onDragOver);
+                prevRootElement.removeEventListener('drop', onDrop);
+            }
+            if (rootElement) {
+                rootElement.addEventListener('dragover', onDragOver);
+                rootElement.addEventListener('drop', onDrop);
+            }
+        });
+    }, [
+        editor,
+        disabled
+    ]);
+    return null;
+}
+exports.VARIABLE_DRAG_MIME = __webpack_exports__.VARIABLE_DRAG_MIME;
+exports.VariableDropPlugin = __webpack_exports__.VariableDropPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "VARIABLE_DRAG_MIME",
+    "VariableDropPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,19 @@
+import type { PromptEditorAutoCompleteOption } from '../types';
+/**
+ * dataTransfer MIME a drag source must set to the variable path string (e.g. `vars.firstName`) for
+ * the editor to treat a drop as a variable insertion. Only this MIME is handled — plain text drops
+ * (e.g. dragging selected text) fall through to the browser's native behaviour untouched.
+ */
+export declare const VARIABLE_DRAG_MIME = "application/x-apollo-prompt-variable";
+export interface VariableDropPluginProps {
+    disabled?: boolean;
+    /** Map a dropped variable path to the token option to insert at the drop point. */
+    mapVarDropToToken: (insertPath: string) => PromptEditorAutoCompleteOption;
+}
+/**
+ * Inserts a variable token when a drag source drops a variable path onto the editor. Native HTML5
+ * drag-drop (no dnd-kit dependency): a consumer's drag source sets the dropped path on
+ * `dataTransfer` (see {@link VARIABLE_DRAG_MIME}); on drop we resolve the caret at the drop point,
+ * map the path to a token via `mapVarDropToToken`, and insert it there.
+ */
+export declare function VariableDropPlugin({ disabled, mapVarDropToToken }: VariableDropPluginProps): null;

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

@@ -0,0 +1,100 @@
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $createRangeSelection, $getNearestNodeFromDOMNode, $getRoot, $isDecoratorNode, $isParagraphNode, $isTextNode, $setSelection } from "lexical";
+import { useEffect, useRef } from "react";
+import { $insertTokenAtCursor } from "../utils/index.js";
+const VARIABLE_DRAG_MIME = 'application/x-apollo-prompt-variable';
+const getCaretFromPoint = (x, y)=>{
+    if (document.caretPositionFromPoint) {
+        const pos = document.caretPositionFromPoint(x, y);
+        return pos ? {
+            offsetNode: pos.offsetNode,
+            offset: pos.offset
+        } : null;
+    }
+    const range = document.caretRangeFromPoint?.(x, y);
+    return range ? {
+        offsetNode: range.startContainer,
+        offset: range.startOffset
+    } : null;
+};
+const $resolveDropPosition = (editor, offsetNode, domOffset, clientX)=>{
+    const node = $getNearestNodeFromDOMNode(offsetNode);
+    if (!node) return null;
+    if ($isDecoratorNode(node)) {
+        const el = editor.getElementByKey(node.getKey());
+        const rect = el?.getBoundingClientRect();
+        const isAfter = rect ? clientX > rect.left + rect.width / 2 : true;
+        const parent = node.getParent();
+        if (!parent) return null;
+        return {
+            key: parent.getKey(),
+            offset: node.getIndexWithinParent() + (isAfter ? 1 : 0),
+            type: 'element'
+        };
+    }
+    if ($isTextNode(node)) return {
+        key: node.getKey(),
+        offset: domOffset,
+        type: 'text'
+    };
+    if ($isParagraphNode(node)) return {
+        key: node.getKey(),
+        offset: domOffset,
+        type: 'element'
+    };
+    return null;
+};
+function VariableDropPlugin({ disabled, mapVarDropToToken }) {
+    const [editor] = useLexicalComposerContext();
+    const mapRef = useRef(mapVarDropToToken);
+    useEffect(()=>{
+        mapRef.current = mapVarDropToToken;
+    });
+    useEffect(()=>{
+        if (disabled) return;
+        const hasVariablePayload = (dt)=>!!dt && dt.types.includes(VARIABLE_DRAG_MIME);
+        const onDragOver = (e)=>{
+            if (!hasVariablePayload(e.dataTransfer)) return;
+            e.preventDefault();
+            if (e.dataTransfer) e.dataTransfer.dropEffect = 'copy';
+        };
+        const onDrop = (e)=>{
+            const path = e.dataTransfer?.getData(VARIABLE_DRAG_MIME);
+            if (!path) return;
+            e.preventDefault();
+            const root = editor.getRootElement();
+            const caret = getCaretFromPoint(e.clientX, e.clientY);
+            editor.update(()=>{
+                let placed = false;
+                if (caret && root?.contains(caret.offsetNode)) {
+                    const resolved = $resolveDropPosition(editor, caret.offsetNode, caret.offset, e.clientX);
+                    if (resolved) {
+                        const sel = $createRangeSelection();
+                        sel.anchor.set(resolved.key, resolved.offset, resolved.type);
+                        sel.focus.set(resolved.key, resolved.offset, resolved.type);
+                        $setSelection(sel);
+                        placed = true;
+                    }
+                }
+                if (!placed) $getRoot().selectEnd();
+                $insertTokenAtCursor(mapRef.current(path));
+            });
+            editor.focus();
+        };
+        return editor.registerRootListener((rootElement, prevRootElement)=>{
+            if (prevRootElement) {
+                prevRootElement.removeEventListener('dragover', onDragOver);
+                prevRootElement.removeEventListener('drop', onDrop);
+            }
+            if (rootElement) {
+                rootElement.addEventListener('dragover', onDragOver);
+                rootElement.addEventListener('drop', onDrop);
+            }
+        });
+    }, [
+        editor,
+        disabled
+    ]);
+    return null;
+}
+export { VARIABLE_DRAG_MIME, VariableDropPlugin };

package/dist/components/ui/prompt-editor/plugins/shared/token-nodes.cjs

@@ -0,0 +1,49 @@
+"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__, {
+    isPromptTokenNode: ()=>isPromptTokenNode,
+    getAllPromptTokenNodes: ()=>getAllPromptTokenNodes
+});
+const utils_namespaceObject = require("@lexical/utils");
+const InputTokenNode_cjs_namespaceObject = require("../../nodes/InputTokenNode.cjs");
+const OutputTokenNode_cjs_namespaceObject = require("../../nodes/OutputTokenNode.cjs");
+const StateTokenNode_cjs_namespaceObject = require("../../nodes/StateTokenNode.cjs");
+const ResourceTokenNode_cjs_namespaceObject = require("../../nodes/ResourceTokenNode.cjs");
+const isPromptTokenNode = (node)=>(0, InputTokenNode_cjs_namespaceObject.isInputTokenNode)(node) || (0, OutputTokenNode_cjs_namespaceObject.isOutputTokenNode)(node) || (0, StateTokenNode_cjs_namespaceObject.isStateTokenNode)(node) || (0, ResourceTokenNode_cjs_namespaceObject.isResourceTokenNode)(node);
+const getAllPromptTokenNodes = ()=>{
+    const nodes = [];
+    for (const { node } of (0, utils_namespaceObject.$dfs)())if (isPromptTokenNode(node)) nodes.push(node);
+    return nodes;
+};
+exports.getAllPromptTokenNodes = __webpack_exports__.getAllPromptTokenNodes;
+exports.isPromptTokenNode = __webpack_exports__.isPromptTokenNode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getAllPromptTokenNodes",
+    "isPromptTokenNode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/plugins/shared/token-nodes.d.ts

@@ -0,0 +1,8 @@
+import type { LexicalNode } from 'lexical';
+import { type InputTokenNode } from '../../nodes/InputTokenNode';
+import { type OutputTokenNode } from '../../nodes/OutputTokenNode';
+import { type StateTokenNode } from '../../nodes/StateTokenNode';
+import { type ResourceTokenNode } from '../../nodes/ResourceTokenNode';
+export type PromptTokenNode = InputTokenNode | OutputTokenNode | StateTokenNode | ResourceTokenNode;
+export declare const isPromptTokenNode: (node: LexicalNode | null | undefined) => node is PromptTokenNode;
+export declare const getAllPromptTokenNodes: () => PromptTokenNode[];

package/dist/components/ui/prompt-editor/plugins/shared/token-nodes.js

@@ -0,0 +1,12 @@
+import { $dfs } from "@lexical/utils";
+import { isInputTokenNode } from "../../nodes/InputTokenNode.js";
+import { isOutputTokenNode } from "../../nodes/OutputTokenNode.js";
+import { isStateTokenNode } from "../../nodes/StateTokenNode.js";
+import { isResourceTokenNode } from "../../nodes/ResourceTokenNode.js";
+const isPromptTokenNode = (node)=>isInputTokenNode(node) || isOutputTokenNode(node) || isStateTokenNode(node) || isResourceTokenNode(node);
+const getAllPromptTokenNodes = ()=>{
+    const nodes = [];
+    for (const { node } of $dfs())if (isPromptTokenNode(node)) nodes.push(node);
+    return nodes;
+};
+export { getAllPromptTokenNodes, isPromptTokenNode };