@uipath/apollo-wind 2.23.0 → 2.24.0

package/dist/components/ui/prompt-editor/nodes/InputTokenNode.cjs

@@ -0,0 +1,145 @@
+"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__, {
+    isInputTokenNode: ()=>isInputTokenNode,
+    createInputTokenNode: ()=>createInputTokenNode,
+    InputTokenNode: ()=>InputTokenNode
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_lexical_namespaceObject = require("lexical");
+const TokenPillWithTooltip_cjs_namespaceObject = require("../components/TokenPillWithTooltip.cjs");
+class InputTokenNode extends external_lexical_namespaceObject.DecoratorNode {
+    __value;
+    __diffType;
+    __isInvalid;
+    static getType() {
+        return 'input-token';
+    }
+    static clone(node) {
+        const cloned = new InputTokenNode(node.__value, node.__key, node.__diffType);
+        cloned.__isInvalid = node.__isInvalid;
+        return cloned;
+    }
+    constructor(value, key, diffType){
+        super(key);
+        this.__value = value;
+        this.__diffType = diffType;
+    }
+    getValue() {
+        return this.__value;
+    }
+    setValue(value) {
+        const self = this.getWritable();
+        self.__value = value;
+        return self;
+    }
+    getIsInvalid() {
+        return this.__isInvalid ?? false;
+    }
+    setIsInvalid(isInvalid) {
+        const self = this.getWritable();
+        self.__isInvalid = isInvalid;
+        return self;
+    }
+    createDOM() {
+        const span = document.createElement('span');
+        span.style.display = 'inline';
+        return span;
+    }
+    updateDOM() {
+        return false;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.dataset.lexicalInputToken = 'true';
+        element.dataset.value = this.__value;
+        element.textContent = this.__value;
+        return {
+            element
+        };
+    }
+    static importDOM() {
+        return {
+            span: (domNode)=>{
+                if (!('lexicalInputToken' in domNode.dataset)) return null;
+                return {
+                    conversion: (element)=>({
+                            node: new InputTokenNode(element.dataset.value ?? '')
+                        }),
+                    priority: 1
+                };
+            }
+        };
+    }
+    static importJSON(serializedNode) {
+        return new InputTokenNode(serializedNode.value);
+    }
+    exportJSON() {
+        return {
+            type: 'input-token',
+            value: this.__value,
+            version: 1
+        };
+    }
+    getTextContent() {
+        return this.__value;
+    }
+    isInline() {
+        return true;
+    }
+    isKeyboardSelectable() {
+        return true;
+    }
+    decorate(editor) {
+        const readonly = !editor.isEditable();
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(TokenPillWithTooltip_cjs_namespaceObject.TokenPillWithTooltip, {
+            value: this.__value,
+            tokenType: "input",
+            nodeKey: this.getKey(),
+            diffType: this.__diffType,
+            readonly: readonly,
+            isInvalid: this.__isInvalid,
+            onRemove: ()=>{
+                if (!readonly) editor.update(()=>{
+                    this.remove();
+                });
+            }
+        });
+    }
+}
+const createInputTokenNode = (value, diffType)=>(0, external_lexical_namespaceObject.$applyNodeReplacement)(new InputTokenNode(value, void 0, diffType));
+const isInputTokenNode = (node)=>node instanceof InputTokenNode;
+exports.InputTokenNode = __webpack_exports__.InputTokenNode;
+exports.createInputTokenNode = __webpack_exports__.createInputTokenNode;
+exports.isInputTokenNode = __webpack_exports__.isInputTokenNode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "InputTokenNode",
+    "createInputTokenNode",
+    "isInputTokenNode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/nodes/InputTokenNode.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import { DecoratorNode, type DOMConversionMap, type DOMExportOutput, type LexicalEditor, type LexicalNode, type NodeKey, type SerializedLexicalNode, type Spread } from 'lexical';
+import type { PromptEditorDiffType } from '../types';
+export type SerializedInputTokenNode = Spread<{
+    value: string;
+}, SerializedLexicalNode>;
+export declare class InputTokenNode extends DecoratorNode<ReactNode> {
+    __value: string;
+    __diffType?: PromptEditorDiffType;
+    __isInvalid?: boolean;
+    static getType(): string;
+    static clone(node: InputTokenNode): InputTokenNode;
+    constructor(value: string, key?: NodeKey, diffType?: PromptEditorDiffType);
+    getValue(): string;
+    setValue(value: string): this;
+    getIsInvalid(): boolean;
+    setIsInvalid(isInvalid: boolean): this;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedInputTokenNode): InputTokenNode;
+    exportJSON(): SerializedInputTokenNode;
+    getTextContent(): string;
+    isInline(): boolean;
+    isKeyboardSelectable(): boolean;
+    decorate(editor: LexicalEditor): ReactNode;
+}
+export declare const createInputTokenNode: (value: string, diffType?: PromptEditorDiffType) => InputTokenNode;
+export declare const isInputTokenNode: (node: LexicalNode | null | undefined) => node is InputTokenNode;

package/dist/components/ui/prompt-editor/nodes/InputTokenNode.js

@@ -0,0 +1,105 @@
+import { jsx } from "react/jsx-runtime";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import { TokenPillWithTooltip } from "../components/TokenPillWithTooltip.js";
+class InputTokenNode extends DecoratorNode {
+    __value;
+    __diffType;
+    __isInvalid;
+    static getType() {
+        return 'input-token';
+    }
+    static clone(node) {
+        const cloned = new InputTokenNode(node.__value, node.__key, node.__diffType);
+        cloned.__isInvalid = node.__isInvalid;
+        return cloned;
+    }
+    constructor(value, key, diffType){
+        super(key);
+        this.__value = value;
+        this.__diffType = diffType;
+    }
+    getValue() {
+        return this.__value;
+    }
+    setValue(value) {
+        const self = this.getWritable();
+        self.__value = value;
+        return self;
+    }
+    getIsInvalid() {
+        return this.__isInvalid ?? false;
+    }
+    setIsInvalid(isInvalid) {
+        const self = this.getWritable();
+        self.__isInvalid = isInvalid;
+        return self;
+    }
+    createDOM() {
+        const span = document.createElement('span');
+        span.style.display = 'inline';
+        return span;
+    }
+    updateDOM() {
+        return false;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.dataset.lexicalInputToken = 'true';
+        element.dataset.value = this.__value;
+        element.textContent = this.__value;
+        return {
+            element
+        };
+    }
+    static importDOM() {
+        return {
+            span: (domNode)=>{
+                if (!('lexicalInputToken' in domNode.dataset)) return null;
+                return {
+                    conversion: (element)=>({
+                            node: new InputTokenNode(element.dataset.value ?? '')
+                        }),
+                    priority: 1
+                };
+            }
+        };
+    }
+    static importJSON(serializedNode) {
+        return new InputTokenNode(serializedNode.value);
+    }
+    exportJSON() {
+        return {
+            type: 'input-token',
+            value: this.__value,
+            version: 1
+        };
+    }
+    getTextContent() {
+        return this.__value;
+    }
+    isInline() {
+        return true;
+    }
+    isKeyboardSelectable() {
+        return true;
+    }
+    decorate(editor) {
+        const readonly = !editor.isEditable();
+        return /*#__PURE__*/ jsx(TokenPillWithTooltip, {
+            value: this.__value,
+            tokenType: "input",
+            nodeKey: this.getKey(),
+            diffType: this.__diffType,
+            readonly: readonly,
+            isInvalid: this.__isInvalid,
+            onRemove: ()=>{
+                if (!readonly) editor.update(()=>{
+                    this.remove();
+                });
+            }
+        });
+    }
+}
+const createInputTokenNode = (value, diffType)=>$applyNodeReplacement(new InputTokenNode(value, void 0, diffType));
+const isInputTokenNode = (node)=>node instanceof InputTokenNode;
+export { InputTokenNode, createInputTokenNode, isInputTokenNode };

package/dist/components/ui/prompt-editor/nodes/OutputTokenNode.cjs

@@ -0,0 +1,145 @@
+"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__, {
+    isOutputTokenNode: ()=>isOutputTokenNode,
+    OutputTokenNode: ()=>OutputTokenNode,
+    createOutputTokenNode: ()=>createOutputTokenNode
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_lexical_namespaceObject = require("lexical");
+const TokenPillWithTooltip_cjs_namespaceObject = require("../components/TokenPillWithTooltip.cjs");
+class OutputTokenNode extends external_lexical_namespaceObject.DecoratorNode {
+    __value;
+    __diffType;
+    __isInvalid;
+    static getType() {
+        return 'output-token';
+    }
+    static clone(node) {
+        const cloned = new OutputTokenNode(node.__value, node.__key, node.__diffType);
+        cloned.__isInvalid = node.__isInvalid;
+        return cloned;
+    }
+    constructor(value, key, diffType){
+        super(key);
+        this.__value = value;
+        this.__diffType = diffType;
+    }
+    getValue() {
+        return this.__value;
+    }
+    setValue(value) {
+        const self = this.getWritable();
+        self.__value = value;
+        return self;
+    }
+    getIsInvalid() {
+        return this.__isInvalid ?? false;
+    }
+    setIsInvalid(isInvalid) {
+        const self = this.getWritable();
+        self.__isInvalid = isInvalid;
+        return self;
+    }
+    createDOM() {
+        const span = document.createElement('span');
+        span.style.display = 'inline';
+        return span;
+    }
+    updateDOM() {
+        return false;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.dataset.lexicalOutputToken = 'true';
+        element.dataset.value = this.__value;
+        element.textContent = this.__value;
+        return {
+            element
+        };
+    }
+    static importDOM() {
+        return {
+            span: (domNode)=>{
+                if (!('lexicalOutputToken' in domNode.dataset)) return null;
+                return {
+                    conversion: (element)=>({
+                            node: new OutputTokenNode(element.dataset.value ?? '')
+                        }),
+                    priority: 1
+                };
+            }
+        };
+    }
+    static importJSON(serializedNode) {
+        return new OutputTokenNode(serializedNode.value);
+    }
+    exportJSON() {
+        return {
+            type: 'output-token',
+            value: this.__value,
+            version: 1
+        };
+    }
+    getTextContent() {
+        return this.__value;
+    }
+    isInline() {
+        return true;
+    }
+    isKeyboardSelectable() {
+        return true;
+    }
+    decorate(editor) {
+        const readonly = !editor.isEditable();
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(TokenPillWithTooltip_cjs_namespaceObject.TokenPillWithTooltip, {
+            value: this.__value,
+            tokenType: "output",
+            nodeKey: this.getKey(),
+            diffType: this.__diffType,
+            readonly: readonly,
+            isInvalid: this.__isInvalid,
+            onRemove: ()=>{
+                if (!readonly) editor.update(()=>{
+                    this.remove();
+                });
+            }
+        });
+    }
+}
+const createOutputTokenNode = (value, diffType)=>(0, external_lexical_namespaceObject.$applyNodeReplacement)(new OutputTokenNode(value, void 0, diffType));
+const isOutputTokenNode = (node)=>node instanceof OutputTokenNode;
+exports.OutputTokenNode = __webpack_exports__.OutputTokenNode;
+exports.createOutputTokenNode = __webpack_exports__.createOutputTokenNode;
+exports.isOutputTokenNode = __webpack_exports__.isOutputTokenNode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OutputTokenNode",
+    "createOutputTokenNode",
+    "isOutputTokenNode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/nodes/OutputTokenNode.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import { DecoratorNode, type DOMConversionMap, type DOMExportOutput, type LexicalEditor, type LexicalNode, type NodeKey, type SerializedLexicalNode, type Spread } from 'lexical';
+import type { PromptEditorDiffType } from '../types';
+export type SerializedOutputTokenNode = Spread<{
+    value: string;
+}, SerializedLexicalNode>;
+export declare class OutputTokenNode extends DecoratorNode<ReactNode> {
+    __value: string;
+    __diffType?: PromptEditorDiffType;
+    __isInvalid?: boolean;
+    static getType(): string;
+    static clone(node: OutputTokenNode): OutputTokenNode;
+    constructor(value: string, key?: NodeKey, diffType?: PromptEditorDiffType);
+    getValue(): string;
+    setValue(value: string): this;
+    getIsInvalid(): boolean;
+    setIsInvalid(isInvalid: boolean): this;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedOutputTokenNode): OutputTokenNode;
+    exportJSON(): SerializedOutputTokenNode;
+    getTextContent(): string;
+    isInline(): boolean;
+    isKeyboardSelectable(): boolean;
+    decorate(editor: LexicalEditor): ReactNode;
+}
+export declare const createOutputTokenNode: (value: string, diffType?: PromptEditorDiffType) => OutputTokenNode;
+export declare const isOutputTokenNode: (node: LexicalNode | null | undefined) => node is OutputTokenNode;

package/dist/components/ui/prompt-editor/nodes/OutputTokenNode.js

@@ -0,0 +1,105 @@
+import { jsx } from "react/jsx-runtime";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import { TokenPillWithTooltip } from "../components/TokenPillWithTooltip.js";
+class OutputTokenNode extends DecoratorNode {
+    __value;
+    __diffType;
+    __isInvalid;
+    static getType() {
+        return 'output-token';
+    }
+    static clone(node) {
+        const cloned = new OutputTokenNode(node.__value, node.__key, node.__diffType);
+        cloned.__isInvalid = node.__isInvalid;
+        return cloned;
+    }
+    constructor(value, key, diffType){
+        super(key);
+        this.__value = value;
+        this.__diffType = diffType;
+    }
+    getValue() {
+        return this.__value;
+    }
+    setValue(value) {
+        const self = this.getWritable();
+        self.__value = value;
+        return self;
+    }
+    getIsInvalid() {
+        return this.__isInvalid ?? false;
+    }
+    setIsInvalid(isInvalid) {
+        const self = this.getWritable();
+        self.__isInvalid = isInvalid;
+        return self;
+    }
+    createDOM() {
+        const span = document.createElement('span');
+        span.style.display = 'inline';
+        return span;
+    }
+    updateDOM() {
+        return false;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.dataset.lexicalOutputToken = 'true';
+        element.dataset.value = this.__value;
+        element.textContent = this.__value;
+        return {
+            element
+        };
+    }
+    static importDOM() {
+        return {
+            span: (domNode)=>{
+                if (!('lexicalOutputToken' in domNode.dataset)) return null;
+                return {
+                    conversion: (element)=>({
+                            node: new OutputTokenNode(element.dataset.value ?? '')
+                        }),
+                    priority: 1
+                };
+            }
+        };
+    }
+    static importJSON(serializedNode) {
+        return new OutputTokenNode(serializedNode.value);
+    }
+    exportJSON() {
+        return {
+            type: 'output-token',
+            value: this.__value,
+            version: 1
+        };
+    }
+    getTextContent() {
+        return this.__value;
+    }
+    isInline() {
+        return true;
+    }
+    isKeyboardSelectable() {
+        return true;
+    }
+    decorate(editor) {
+        const readonly = !editor.isEditable();
+        return /*#__PURE__*/ jsx(TokenPillWithTooltip, {
+            value: this.__value,
+            tokenType: "output",
+            nodeKey: this.getKey(),
+            diffType: this.__diffType,
+            readonly: readonly,
+            isInvalid: this.__isInvalid,
+            onRemove: ()=>{
+                if (!readonly) editor.update(()=>{
+                    this.remove();
+                });
+            }
+        });
+    }
+}
+const createOutputTokenNode = (value, diffType)=>$applyNodeReplacement(new OutputTokenNode(value, void 0, diffType));
+const isOutputTokenNode = (node)=>node instanceof OutputTokenNode;
+export { OutputTokenNode, createOutputTokenNode, isOutputTokenNode };