@uipath/apollo-wind 2.23.0 → 2.24.0

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

@@ -0,0 +1,130 @@
+import { useEffect } from "react";
+import { $generateNodesFromSerializedNodes, $getLexicalContent, $insertGeneratedNodes } from "@lexical/clipboard";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister } from "@lexical/utils";
+import { $createRangeSelectionFromDom, $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, COPY_COMMAND, CUT_COMMAND, PASTE_COMMAND } from "lexical";
+import { createInputTokenNode, createOutputTokenNode, createResourceTokenNode, createStateTokenNode } from "../nodes/index.js";
+import { clipboardStringToTokens, getEditorTokensFromSelection, tokensToClipboardString } from "../utils/index.js";
+const LEXICAL_MIME = 'application/x-lexical-editor';
+const copySelectionToClipboard = (editor, clipboardData, selection)=>{
+    const tokens = getEditorTokensFromSelection(selection);
+    if (0 === tokens.length) return false;
+    clipboardData.setData('text/plain', tokensToClipboardString(tokens));
+    const lexicalJson = $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 = $generateNodesFromSerializedNodes(parsed.nodes);
+        if (0 === nodes.length) return false;
+        $insertGeneratedNodes(editor, nodes, selection);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const insertTokensAtSelection = (tokens, selection)=>{
+    if (!$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 = createInputTokenNode(token.value);
+                break;
+            case 'output':
+                tokenNode = createOutputTokenNode(token.value);
+                break;
+            case 'state':
+                tokenNode = createStateTokenNode(token.value);
+                break;
+            case 'resource':
+                tokenNode = 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 = clipboardStringToTokens(text);
+    if (0 === tokens.length) return false;
+    insertTokensAtSelection(tokens, selection);
+    return true;
+};
+const CopyPastePlugin = ()=>{
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>mergeRegister(editor.registerCommand(COPY_COMMAND, (event)=>{
+            if (!event || !('clipboardData' in event) || !event.clipboardData) return false;
+            let handled = false;
+            editor.read(()=>{
+                let selection = $getSelection();
+                if (!selection || $isRangeSelection(selection) && selection.isCollapsed()) {
+                    const domSelection = window.getSelection();
+                    const rootElement = editor.getRootElement();
+                    if (domSelection && rootElement && !domSelection.isCollapsed) selection = $createRangeSelectionFromDom(domSelection, editor);
+                }
+                if (!selection || $isRangeSelection(selection) && selection.isCollapsed()) return;
+                handled = copySelectionToClipboard(editor, event.clipboardData, selection);
+            });
+            if (handled) event.preventDefault();
+            return handled;
+        }, COMMAND_PRIORITY_CRITICAL), editor.registerCommand(CUT_COMMAND, (event)=>{
+            if (!event || !('clipboardData' in event) || !event.clipboardData) return false;
+            let handled = false;
+            editor.read(()=>{
+                let selection = $getSelection();
+                if (!selection || $isRangeSelection(selection) && selection.isCollapsed()) {
+                    const domSelection = window.getSelection();
+                    const rootElement = editor.getRootElement();
+                    if (domSelection && rootElement && !domSelection.isCollapsed) selection = $createRangeSelectionFromDom(domSelection, editor);
+                }
+                if (!selection || $isRangeSelection(selection) && selection.isCollapsed()) return;
+                handled = copySelectionToClipboard(editor, event.clipboardData, selection);
+            });
+            if (handled) {
+                event.preventDefault();
+                editor.update(()=>{
+                    const selection = $getSelection();
+                    if (selection && $isRangeSelection(selection)) selection.removeText();
+                });
+            }
+            return handled;
+        }, COMMAND_PRIORITY_CRITICAL), editor.registerCommand(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 = $getSelection();
+                if (!selection) return;
+                if (hasLexicalJson && tryPasteLexicalContent(editor, clipboardData, selection)) return;
+                if (hasPlainText) pasteTextContent(plainText, selection);
+            }, {
+                discrete: true
+            });
+            return true;
+        }, COMMAND_PRIORITY_CRITICAL)), [
+        editor
+    ]);
+    return null;
+};
+export { CopyPastePlugin };

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

@@ -0,0 +1,50 @@
+"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__, {
+    EditorRefPlugin: ()=>EditorRefPlugin
+});
+const external_react_namespaceObject = require("react");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const EditorRefPlugin = ({ onRef })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const onRefRef = (0, external_react_namespaceObject.useRef)(onRef);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        onRefRef.current = onRef;
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        onRefRef.current(editor);
+    }, [
+        editor
+    ]);
+    return null;
+};
+exports.EditorRefPlugin = __webpack_exports__.EditorRefPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EditorRefPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,4 @@
+import type { LexicalEditor } from 'lexical';
+export declare const EditorRefPlugin: ({ onRef }: {
+    onRef: (editor: LexicalEditor) => void;
+}) => null;

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

@@ -0,0 +1,16 @@
+import { useEffect, useRef } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+const EditorRefPlugin = ({ onRef })=>{
+    const [editor] = useLexicalComposerContext();
+    const onRefRef = useRef(onRef);
+    useEffect(()=>{
+        onRefRef.current = onRef;
+    });
+    useEffect(()=>{
+        onRefRef.current(editor);
+    }, [
+        editor
+    ]);
+    return null;
+};
+export { EditorRefPlugin };

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

@@ -0,0 +1,108 @@
+"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__, {
+    MultilinePlugin: ()=>MultilinePlugin
+});
+const external_react_namespaceObject = require("react");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const utils_namespaceObject = require("@lexical/utils");
+const external_lexical_namespaceObject = require("lexical");
+const collapseParagraphs = ()=>{
+    const root = (0, external_lexical_namespaceObject.$getRoot)();
+    const paragraphs = root.getChildren().filter(external_lexical_namespaceObject.$isParagraphNode);
+    if (paragraphs.length <= 1) return;
+    const allNodes = [];
+    for (const [i, paragraph] of paragraphs.entries()){
+        const children = paragraph.getChildren();
+        if (i > 0 && children.length > 0) allNodes.push((0, external_lexical_namespaceObject.$createTextNode)(' '));
+        for (const child of children)allNodes.push(child);
+    }
+    const newParagraph = (0, external_lexical_namespaceObject.$createParagraphNode)();
+    for (const node of allNodes)newParagraph.append(node);
+    root.clear();
+    root.append(newParagraph);
+};
+const stripNewlinesFromText = (text)=>text.replace(/\n+/g, ' ');
+const MultilinePlugin = ({ multiline })=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const prevMultilineRef = (0, external_react_namespaceObject.useRef)(null);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const wasMultiline = prevMultilineRef.current;
+        prevMultilineRef.current = multiline;
+        const isInitialMount = null === wasMultiline;
+        const switchedToSingleLine = true === wasMultiline && !multiline;
+        if (!multiline && (isInitialMount || switchedToSingleLine)) {
+            const timeoutId = setTimeout(()=>{
+                editor.update(()=>{
+                    collapseParagraphs();
+                    const root = (0, external_lexical_namespaceObject.$getRoot)();
+                    const paragraphs = root.getChildren().filter(external_lexical_namespaceObject.$isParagraphNode);
+                    for (const paragraph of paragraphs){
+                        const children = paragraph.getChildren();
+                        for (const child of children)if ((0, external_lexical_namespaceObject.$isLineBreakNode)(child)) {
+                            const prev = child.getPreviousSibling();
+                            const next = child.getNextSibling();
+                            if (prev && next) child.replace((0, external_lexical_namespaceObject.$createTextNode)(' '));
+                            else child.remove();
+                        } else if (child instanceof external_lexical_namespaceObject.TextNode) {
+                            const text = child.getTextContent();
+                            if (text.includes('\n')) {
+                                const newText = stripNewlinesFromText(text);
+                                if ('' === newText.trim()) child.remove();
+                                else child.setTextContent(newText);
+                            }
+                        }
+                    }
+                });
+            }, 0);
+            return ()=>clearTimeout(timeoutId);
+        }
+    }, [
+        editor,
+        multiline
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (multiline) return;
+        return (0, utils_namespaceObject.mergeRegister)(editor.registerCommand(external_lexical_namespaceObject.KEY_ENTER_COMMAND, (event)=>{
+            event?.preventDefault();
+            return true;
+        }, external_lexical_namespaceObject.COMMAND_PRIORITY_NORMAL), editor.registerNodeTransform(external_lexical_namespaceObject.TextNode, (node)=>{
+            const text = node.getTextContent();
+            if (text.includes('\n')) node.setTextContent(stripNewlinesFromText(text));
+        }));
+    }, [
+        editor,
+        multiline
+    ]);
+    return null;
+};
+exports.MultilinePlugin = __webpack_exports__.MultilinePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MultilinePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,3 @@
+export declare const MultilinePlugin: ({ multiline }: {
+    multiline: boolean;
+}) => null;

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

@@ -0,0 +1,74 @@
+import { useEffect, useRef } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister } from "@lexical/utils";
+import { $createParagraphNode, $createTextNode, $getRoot, $isLineBreakNode, $isParagraphNode, COMMAND_PRIORITY_NORMAL, KEY_ENTER_COMMAND, TextNode } from "lexical";
+const collapseParagraphs = ()=>{
+    const root = $getRoot();
+    const paragraphs = root.getChildren().filter($isParagraphNode);
+    if (paragraphs.length <= 1) return;
+    const allNodes = [];
+    for (const [i, paragraph] of paragraphs.entries()){
+        const children = paragraph.getChildren();
+        if (i > 0 && children.length > 0) allNodes.push($createTextNode(' '));
+        for (const child of children)allNodes.push(child);
+    }
+    const newParagraph = $createParagraphNode();
+    for (const node of allNodes)newParagraph.append(node);
+    root.clear();
+    root.append(newParagraph);
+};
+const stripNewlinesFromText = (text)=>text.replace(/\n+/g, ' ');
+const MultilinePlugin = ({ multiline })=>{
+    const [editor] = useLexicalComposerContext();
+    const prevMultilineRef = useRef(null);
+    useEffect(()=>{
+        const wasMultiline = prevMultilineRef.current;
+        prevMultilineRef.current = multiline;
+        const isInitialMount = null === wasMultiline;
+        const switchedToSingleLine = true === wasMultiline && !multiline;
+        if (!multiline && (isInitialMount || switchedToSingleLine)) {
+            const timeoutId = setTimeout(()=>{
+                editor.update(()=>{
+                    collapseParagraphs();
+                    const root = $getRoot();
+                    const paragraphs = root.getChildren().filter($isParagraphNode);
+                    for (const paragraph of paragraphs){
+                        const children = paragraph.getChildren();
+                        for (const child of children)if ($isLineBreakNode(child)) {
+                            const prev = child.getPreviousSibling();
+                            const next = child.getNextSibling();
+                            if (prev && next) child.replace($createTextNode(' '));
+                            else child.remove();
+                        } else if (child instanceof TextNode) {
+                            const text = child.getTextContent();
+                            if (text.includes('\n')) {
+                                const newText = stripNewlinesFromText(text);
+                                if ('' === newText.trim()) child.remove();
+                                else child.setTextContent(newText);
+                            }
+                        }
+                    }
+                });
+            }, 0);
+            return ()=>clearTimeout(timeoutId);
+        }
+    }, [
+        editor,
+        multiline
+    ]);
+    useEffect(()=>{
+        if (multiline) return;
+        return mergeRegister(editor.registerCommand(KEY_ENTER_COMMAND, (event)=>{
+            event?.preventDefault();
+            return true;
+        }, COMMAND_PRIORITY_NORMAL), editor.registerNodeTransform(TextNode, (node)=>{
+            const text = node.getTextContent();
+            if (text.includes('\n')) node.setTextContent(stripNewlinesFromText(text));
+        }));
+    }, [
+        editor,
+        multiline
+    ]);
+    return null;
+};
+export { MultilinePlugin };