@uipath/apollo-wind 2.23.0 → 2.24.0

package/dist/components/ui/prompt-editor/utils/comparison.cjs

@@ -0,0 +1,39 @@
+"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__, {
+    areTokensEqual: ()=>areTokensEqual
+});
+const areTokensEqual = (a, b)=>{
+    if (a.length !== b.length) return false;
+    return a.every((token, i)=>token.type === b[i].type && token.value === b[i].value);
+};
+exports.areTokensEqual = __webpack_exports__.areTokensEqual;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "areTokensEqual"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/comparison.d.ts

@@ -0,0 +1,3 @@
+import type { PromptEditorToken } from '../types';
+/** Check if two token arrays are deeply equal */
+export declare const areTokensEqual: (a: PromptEditorToken[], b: PromptEditorToken[]) => boolean;

package/dist/components/ui/prompt-editor/utils/comparison.js

@@ -0,0 +1,5 @@
+const areTokensEqual = (a, b)=>{
+    if (a.length !== b.length) return false;
+    return a.every((token, i)=>token.type === b[i].type && token.value === b[i].value);
+};
+export { areTokensEqual };

package/dist/components/ui/prompt-editor/utils/index.cjs

@@ -0,0 +1,68 @@
+"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__, {
+    tokensToClipboardString: ()=>external_serialization_cjs_namespaceObject.tokensToClipboardString,
+    $setEditorTokensInternal: ()=>external_serialization_cjs_namespaceObject.$setEditorTokensInternal,
+    areTokensEqual: ()=>external_comparison_cjs_namespaceObject.areTokensEqual,
+    getEditorTokens: ()=>external_serialization_cjs_namespaceObject.getEditorTokens,
+    $getEditorTokensInternal: ()=>external_serialization_cjs_namespaceObject.$getEditorTokensInternal,
+    $insertTokenAtCursor: ()=>external_insert_token_cjs_namespaceObject.$insertTokenAtCursor,
+    clipboardStringToTokens: ()=>external_serialization_cjs_namespaceObject.clipboardStringToTokens,
+    getEditorTokensFromSelection: ()=>external_serialization_cjs_namespaceObject.getEditorTokensFromSelection,
+    createTokenNodeForOption: ()=>external_insert_token_cjs_namespaceObject.createTokenNodeForOption,
+    WORD_JOINER: ()=>external_serialization_cjs_namespaceObject.WORD_JOINER,
+    setEditorTokens: ()=>external_serialization_cjs_namespaceObject.setEditorTokens
+});
+const external_serialization_cjs_namespaceObject = require("./serialization.cjs");
+const external_comparison_cjs_namespaceObject = require("./comparison.cjs");
+const external_insert_token_cjs_namespaceObject = require("./insert-token.cjs");
+exports.$getEditorTokensInternal = __webpack_exports__.$getEditorTokensInternal;
+exports.$insertTokenAtCursor = __webpack_exports__.$insertTokenAtCursor;
+exports.$setEditorTokensInternal = __webpack_exports__.$setEditorTokensInternal;
+exports.WORD_JOINER = __webpack_exports__.WORD_JOINER;
+exports.areTokensEqual = __webpack_exports__.areTokensEqual;
+exports.clipboardStringToTokens = __webpack_exports__.clipboardStringToTokens;
+exports.createTokenNodeForOption = __webpack_exports__.createTokenNodeForOption;
+exports.getEditorTokens = __webpack_exports__.getEditorTokens;
+exports.getEditorTokensFromSelection = __webpack_exports__.getEditorTokensFromSelection;
+exports.setEditorTokens = __webpack_exports__.setEditorTokens;
+exports.tokensToClipboardString = __webpack_exports__.tokensToClipboardString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "$getEditorTokensInternal",
+    "$insertTokenAtCursor",
+    "$setEditorTokensInternal",
+    "WORD_JOINER",
+    "areTokensEqual",
+    "clipboardStringToTokens",
+    "createTokenNodeForOption",
+    "getEditorTokens",
+    "getEditorTokensFromSelection",
+    "setEditorTokens",
+    "tokensToClipboardString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { $getEditorTokensInternal, $setEditorTokensInternal, getEditorTokens, setEditorTokens, tokensToClipboardString, clipboardStringToTokens, getEditorTokensFromSelection, WORD_JOINER, } from './serialization';
+export { areTokensEqual } from './comparison';
+export { $insertTokenAtCursor, createTokenNodeForOption } from './insert-token';

package/dist/components/ui/prompt-editor/utils/index.js

@@ -0,0 +1,4 @@
+import { $getEditorTokensInternal, $setEditorTokensInternal, WORD_JOINER, clipboardStringToTokens, getEditorTokens, getEditorTokensFromSelection, setEditorTokens, tokensToClipboardString } from "./serialization.js";
+import { areTokensEqual } from "./comparison.js";
+import { $insertTokenAtCursor, createTokenNodeForOption } from "./insert-token.js";
+export { $getEditorTokensInternal, $insertTokenAtCursor, $setEditorTokensInternal, WORD_JOINER, areTokensEqual, clipboardStringToTokens, createTokenNodeForOption, getEditorTokens, getEditorTokensFromSelection, setEditorTokens, tokensToClipboardString };

package/dist/components/ui/prompt-editor/utils/insert-token.cjs

@@ -0,0 +1,103 @@
+"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__, {
+    createTokenNodeForOption: ()=>createTokenNodeForOption,
+    $insertTokenAtCursor: ()=>$insertTokenAtCursor
+});
+const external_lexical_namespaceObject = require("lexical");
+const index_cjs_namespaceObject = require("../nodes/index.cjs");
+const createTokenNodeForOption = (option)=>{
+    switch(option.type){
+        case 'input':
+            return (0, index_cjs_namespaceObject.createInputTokenNode)(option.value);
+        case 'output':
+            return (0, index_cjs_namespaceObject.createOutputTokenNode)(option.value);
+        case 'state':
+            return (0, index_cjs_namespaceObject.createStateTokenNode)(option.value);
+        case 'resource':
+            return (0, index_cjs_namespaceObject.createResourceTokenNode)(option.value);
+        default:
+            return (0, index_cjs_namespaceObject.createInputTokenNode)(option.value);
+    }
+};
+const $insertTokenAtCursor = (option)=>{
+    const tokenNode = createTokenNodeForOption(option);
+    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) {
+        const root = (0, external_lexical_namespaceObject.$getRoot)();
+        const lastChild = root.getLastChild();
+        if (lastChild && (0, external_lexical_namespaceObject.$isElementNode)(lastChild)) lastChild.append(tokenNode);
+        else {
+            const paragraph = (0, external_lexical_namespaceObject.$createParagraphNode)();
+            paragraph.append(tokenNode);
+            root.append(paragraph);
+        }
+        tokenNode.selectNext(0, 0);
+        return;
+    }
+    if (!selection.isCollapsed()) selection.removeText();
+    const anchorNode = selection.anchor.getNode();
+    const anchorOffset = selection.anchor.offset;
+    if ((0, external_lexical_namespaceObject.$isTextNode)(anchorNode)) {
+        const textContent = anchorNode.getTextContent();
+        const textBefore = textContent.slice(0, anchorOffset);
+        const textAfter = textContent.slice(anchorOffset);
+        if (textBefore && textAfter) {
+            anchorNode.setTextContent(textBefore);
+            anchorNode.insertAfter(tokenNode);
+            const textAfterNode = (0, external_lexical_namespaceObject.$createTextNode)(textAfter);
+            tokenNode.insertAfter(textAfterNode);
+            textAfterNode.select(0, 0);
+        } else if (textBefore) {
+            anchorNode.setTextContent(textBefore);
+            anchorNode.insertAfter(tokenNode);
+            tokenNode.selectNext(0, 0);
+        } else if (textAfter) {
+            anchorNode.insertBefore(tokenNode);
+            tokenNode.selectNext(0, 0);
+        } else {
+            anchorNode.replace(tokenNode);
+            tokenNode.selectNext(0, 0);
+        }
+        return;
+    }
+    if ((0, external_lexical_namespaceObject.$isElementNode)(anchorNode)) {
+        const children = anchorNode.getChildren();
+        const childAtOffset = children[anchorOffset];
+        if (childAtOffset) childAtOffset.insertBefore(tokenNode);
+        else anchorNode.append(tokenNode);
+        tokenNode.selectNext(0, 0);
+    }
+};
+exports.$insertTokenAtCursor = __webpack_exports__.$insertTokenAtCursor;
+exports.createTokenNodeForOption = __webpack_exports__.createTokenNodeForOption;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "$insertTokenAtCursor",
+    "createTokenNodeForOption"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/insert-token.d.ts

@@ -0,0 +1,12 @@
+import type { PromptEditorAutoCompleteOption } from '../types';
+/** Create the correct Lexical token decorator node for an autocomplete option. */
+export declare const createTokenNodeForOption: (option: PromptEditorAutoCompleteOption) => import("../nodes").InputTokenNode | import("../nodes").OutputTokenNode | import("../nodes").StateTokenNode | import("../nodes").ResourceTokenNode;
+/**
+ * Insert a token pill at the current cursor position. Must be called inside an
+ * `editor.update(() => ...)` block.
+ *
+ * - Text anchor: splits the text and inserts between the halves (or appends/prepends at edges).
+ * - Element anchor: inserts as a child at the selection offset.
+ * - No selection: appends to the root so the action is not silently dropped.
+ */
+export declare const $insertTokenAtCursor: (option: PromptEditorAutoCompleteOption) => void;

package/dist/components/ui/prompt-editor/utils/insert-token.js

@@ -0,0 +1,66 @@
+import { $createParagraphNode, $createTextNode, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode } from "lexical";
+import { createInputTokenNode, createOutputTokenNode, createResourceTokenNode, createStateTokenNode } from "../nodes/index.js";
+const createTokenNodeForOption = (option)=>{
+    switch(option.type){
+        case 'input':
+            return createInputTokenNode(option.value);
+        case 'output':
+            return createOutputTokenNode(option.value);
+        case 'state':
+            return createStateTokenNode(option.value);
+        case 'resource':
+            return createResourceTokenNode(option.value);
+        default:
+            return createInputTokenNode(option.value);
+    }
+};
+const $insertTokenAtCursor = (option)=>{
+    const tokenNode = createTokenNodeForOption(option);
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) {
+        const root = $getRoot();
+        const lastChild = root.getLastChild();
+        if (lastChild && $isElementNode(lastChild)) lastChild.append(tokenNode);
+        else {
+            const paragraph = $createParagraphNode();
+            paragraph.append(tokenNode);
+            root.append(paragraph);
+        }
+        tokenNode.selectNext(0, 0);
+        return;
+    }
+    if (!selection.isCollapsed()) selection.removeText();
+    const anchorNode = selection.anchor.getNode();
+    const anchorOffset = selection.anchor.offset;
+    if ($isTextNode(anchorNode)) {
+        const textContent = anchorNode.getTextContent();
+        const textBefore = textContent.slice(0, anchorOffset);
+        const textAfter = textContent.slice(anchorOffset);
+        if (textBefore && textAfter) {
+            anchorNode.setTextContent(textBefore);
+            anchorNode.insertAfter(tokenNode);
+            const textAfterNode = $createTextNode(textAfter);
+            tokenNode.insertAfter(textAfterNode);
+            textAfterNode.select(0, 0);
+        } else if (textBefore) {
+            anchorNode.setTextContent(textBefore);
+            anchorNode.insertAfter(tokenNode);
+            tokenNode.selectNext(0, 0);
+        } else if (textAfter) {
+            anchorNode.insertBefore(tokenNode);
+            tokenNode.selectNext(0, 0);
+        } else {
+            anchorNode.replace(tokenNode);
+            tokenNode.selectNext(0, 0);
+        }
+        return;
+    }
+    if ($isElementNode(anchorNode)) {
+        const children = anchorNode.getChildren();
+        const childAtOffset = children[anchorOffset];
+        if (childAtOffset) childAtOffset.insertBefore(tokenNode);
+        else anchorNode.append(tokenNode);
+        tokenNode.selectNext(0, 0);
+    }
+};
+export { $insertTokenAtCursor, createTokenNodeForOption };

package/dist/components/ui/prompt-editor/utils/serialization.cjs

@@ -0,0 +1,255 @@
+"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__, {
+    tokensToClipboardString: ()=>tokensToClipboardString,
+    getEditorTokensFromSelection: ()=>getEditorTokensFromSelection,
+    $setEditorTokensInternal: ()=>$setEditorTokensInternal,
+    getEditorTokens: ()=>getEditorTokens,
+    $getEditorTokensInternal: ()=>$getEditorTokensInternal,
+    setEditorTokens: ()=>setEditorTokens,
+    clipboardStringToTokens: ()=>clipboardStringToTokens,
+    WORD_JOINER: ()=>WORD_JOINER
+});
+const external_lexical_namespaceObject = require("lexical");
+const index_cjs_namespaceObject = require("../nodes/index.cjs");
+const WORD_JOINER = '\u2060';
+const appendTextToken = (tokens, raw)=>{
+    const text = raw.split(WORD_JOINER).join('');
+    if (!text) return;
+    const lastToken = tokens[tokens.length - 1];
+    if (lastToken && 'text' === lastToken.type) lastToken.value += text;
+    else tokens.push({
+        type: 'text',
+        value: text
+    });
+};
+const $getEditorTokensInternal = ()=>{
+    const root = (0, external_lexical_namespaceObject.$getRoot)();
+    const tokens = [];
+    const addText = (raw)=>appendTextToken(tokens, raw);
+    const traverseChildren = (children)=>{
+        for (const node of children)if ((0, external_lexical_namespaceObject.$isTextNode)(node)) addText(node.getTextContent());
+        else if ((0, external_lexical_namespaceObject.$isLineBreakNode)(node)) addText('\n');
+        else if ((0, index_cjs_namespaceObject.isInputTokenNode)(node)) tokens.push({
+            type: 'input',
+            value: node.getValue()
+        });
+        else if ((0, index_cjs_namespaceObject.isOutputTokenNode)(node)) tokens.push({
+            type: 'output',
+            value: node.getValue()
+        });
+        else if ((0, index_cjs_namespaceObject.isStateTokenNode)(node)) tokens.push({
+            type: 'state',
+            value: node.getValue()
+        });
+        else if ((0, index_cjs_namespaceObject.isResourceTokenNode)(node)) tokens.push({
+            type: 'resource',
+            value: node.getValue()
+        });
+    };
+    const paragraphs = root.getChildren();
+    for(let i = 0; i < paragraphs.length; i++){
+        const paragraph = paragraphs[i];
+        if ((0, external_lexical_namespaceObject.$isParagraphNode)(paragraph)) {
+            traverseChildren(paragraph.getChildren());
+            if (i < paragraphs.length - 1) addText('\n');
+        }
+    }
+    return tokens;
+};
+const $setEditorTokensInternal = (tokens)=>{
+    if (!Array.isArray(tokens)) throw new TypeError('setEditorTokensInternal: tokens must be an array');
+    const root = (0, external_lexical_namespaceObject.$getRoot)();
+    root.clear();
+    const currentParagraph = (0, external_lexical_namespaceObject.$createParagraphNode)();
+    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]) currentParagraph.append((0, external_lexical_namespaceObject.$createTextNode)(lines[i]));
+            if (i < lines.length - 1) currentParagraph.append((0, external_lexical_namespaceObject.$createLineBreakNode)());
+        }
+    } else {
+        let node;
+        switch(token.type){
+            case 'input':
+                node = (0, index_cjs_namespaceObject.createInputTokenNode)(token.value);
+                break;
+            case 'output':
+                node = (0, index_cjs_namespaceObject.createOutputTokenNode)(token.value);
+                break;
+            case 'state':
+                node = (0, index_cjs_namespaceObject.createStateTokenNode)(token.value);
+                break;
+            case 'resource':
+                node = (0, index_cjs_namespaceObject.createResourceTokenNode)(token.value);
+                break;
+            default:
+                throw new Error(`Unknown token type: ${token.type}`);
+        }
+        currentParagraph.append(node);
+    }
+    root.append(currentParagraph);
+};
+const getEditorTokens = (editor)=>{
+    let tokens = [];
+    editor.getEditorState().read(()=>{
+        tokens = $getEditorTokensInternal();
+    });
+    return tokens;
+};
+const setEditorTokens = (editor, tokens)=>{
+    editor.update(()=>$setEditorTokensInternal(tokens), {
+        discrete: true
+    });
+};
+const tokensToClipboardString = (tokens)=>{
+    let result = '';
+    for (const token of tokens)if ('text' === token.type) result += token.value;
+    else result += `{{ ${token.value} }}`;
+    return result;
+};
+const clipboardStringToTokens = (str)=>{
+    const tokens = [];
+    let currentText = '';
+    let i = 0;
+    const flushText = ()=>{
+        if (currentText.length > 0) {
+            tokens.push({
+                type: 'text',
+                value: currentText
+            });
+            currentText = '';
+        }
+    };
+    while(i < str.length){
+        if ('{' === str[i] && i + 1 < str.length && '{' === str[i + 1]) {
+            flushText();
+            i += 2;
+            let inner = '';
+            let foundClosing = false;
+            while(i < str.length){
+                if ('}' === str[i] && i + 1 < str.length && '}' === str[i + 1]) {
+                    i += 2;
+                    foundClosing = true;
+                    break;
+                }
+                inner += str[i];
+                i++;
+            }
+            if (foundClosing && inner.trim()) tokens.push({
+                type: 'input',
+                value: inner.trim()
+            });
+            else if (foundClosing) currentText += '{{}}';
+            else currentText += `{{${inner}`;
+            continue;
+        }
+        currentText += str[i];
+        i++;
+    }
+    flushText();
+    return tokens;
+};
+const getEditorTokensFromSelection = (selection)=>{
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection)) return [];
+    if (selection.isCollapsed()) return [];
+    const tokens = [];
+    const addText = (raw)=>appendTextToken(tokens, raw);
+    const selectedNodes = selection.getNodes();
+    const anchorKey = selection.anchor.key;
+    const focusKey = selection.focus.key;
+    const anchorOffset = selection.anchor.offset;
+    const focusOffset = selection.focus.offset;
+    const anchorNode = selection.anchor.getNode();
+    const nodeKeys = new Set(selectedNodes.map((n)=>n.getKey()));
+    const nodesToProcess = [];
+    if ((0, external_lexical_namespaceObject.$isTextNode)(anchorNode) && !nodeKeys.has(anchorKey)) nodesToProcess.push(anchorNode);
+    nodesToProcess.push(...selectedNodes);
+    if (0 === nodesToProcess.length) return [];
+    const firstSelectedNode = nodesToProcess[0];
+    const isForward = 1 === nodesToProcess.length ? anchorOffset <= focusOffset : firstSelectedNode.getKey() === anchorKey || firstSelectedNode.getParent()?.getKey() === anchorKey;
+    let prevNodeParagraph = null;
+    for (const node of nodesToProcess){
+        const nodeKey = node.getKey();
+        const nodeType = node.getType();
+        const nodeParagraph = (0, external_lexical_namespaceObject.$isParagraphNode)(node) ? node : node.getParent();
+        if (prevNodeParagraph && nodeParagraph && prevNodeParagraph !== nodeParagraph) addText('\n');
+        prevNodeParagraph = nodeParagraph;
+        if (!(0, external_lexical_namespaceObject.$isParagraphNode)(node)) {
+            if ('input-token' === nodeType) tokens.push({
+                type: 'input',
+                value: node.getValue()
+            });
+            else if ('output-token' === nodeType) tokens.push({
+                type: 'output',
+                value: node.getValue()
+            });
+            else if ('state-token' === nodeType) tokens.push({
+                type: 'state',
+                value: node.getValue()
+            });
+            else if ('resource-token' === nodeType) tokens.push({
+                type: 'resource',
+                value: node.getValue()
+            });
+            else if ((0, external_lexical_namespaceObject.$isTextNode)(node)) {
+                const textContent = node.getTextContent();
+                let selectedText = textContent;
+                const isAnchorNode = nodeKey === anchorKey;
+                const isFocusNode = nodeKey === focusKey;
+                if (isAnchorNode && isFocusNode) {
+                    const start = Math.min(anchorOffset, focusOffset);
+                    const end = Math.max(anchorOffset, focusOffset);
+                    selectedText = textContent.slice(start, end);
+                } else if (isAnchorNode) selectedText = isForward ? textContent.slice(anchorOffset) : textContent.slice(0, anchorOffset);
+                else if (isFocusNode) selectedText = isForward ? textContent.slice(0, focusOffset) : textContent.slice(focusOffset);
+                if (selectedText) addText(selectedText);
+            } else if ((0, external_lexical_namespaceObject.$isLineBreakNode)(node)) addText('\n');
+        }
+    }
+    return tokens;
+};
+exports.$getEditorTokensInternal = __webpack_exports__.$getEditorTokensInternal;
+exports.$setEditorTokensInternal = __webpack_exports__.$setEditorTokensInternal;
+exports.WORD_JOINER = __webpack_exports__.WORD_JOINER;
+exports.clipboardStringToTokens = __webpack_exports__.clipboardStringToTokens;
+exports.getEditorTokens = __webpack_exports__.getEditorTokens;
+exports.getEditorTokensFromSelection = __webpack_exports__.getEditorTokensFromSelection;
+exports.setEditorTokens = __webpack_exports__.setEditorTokens;
+exports.tokensToClipboardString = __webpack_exports__.tokensToClipboardString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "$getEditorTokensInternal",
+    "$setEditorTokensInternal",
+    "WORD_JOINER",
+    "clipboardStringToTokens",
+    "getEditorTokens",
+    "getEditorTokensFromSelection",
+    "setEditorTokens",
+    "tokensToClipboardString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/utils/serialization.d.ts

@@ -0,0 +1,16 @@
+import { type BaseSelection, type LexicalEditor } from 'lexical';
+import type { PromptEditorToken } from '../types';
+/** U+2060 WORD JOINER — zero-width, used as a caret anchor next to inline token pills. Explicit
+ *  escape (not the invisible literal) so it can't be silently dropped/altered by editors. */
+export declare const WORD_JOINER = "\u2060";
+export declare const $getEditorTokensInternal: () => PromptEditorToken[];
+/** Convert PromptEditorToken[] to Lexical editor state */
+export declare const $setEditorTokensInternal: (tokens: PromptEditorToken[]) => void;
+export declare const getEditorTokens: (editor: LexicalEditor) => PromptEditorToken[];
+export declare const setEditorTokens: (editor: LexicalEditor, tokens: PromptEditorToken[]) => void;
+/** Serialize tokens to clipboard-friendly string (using {{ }} for variables) */
+export declare const tokensToClipboardString: (tokens: PromptEditorToken[]) => string;
+/** Parse a clipboard string back into tokens */
+export declare const clipboardStringToTokens: (str: string) => PromptEditorToken[];
+/** Get tokens from a selection (for copy/cut operations) */
+export declare const getEditorTokensFromSelection: (selection: BaseSelection) => PromptEditorToken[];