@apia/ai 4.0.9 → 4.0.13

package/index.ts/index.js

@@ -0,0 +1,1898 @@
+import { jsx, jsxs, Fragment } from '@apia/theme/jsx-runtime';
+import { Box, getVariant, useBreakpointIndex, Textarea, Paragraph } from '@apia/theme';
+import { useRef, useCallback, useState, createContext } from 'react';
+import { IconButton, SimpleButton, ApiaUtil, FiltersStore, SortableList, SortableListItem } from '@apia/components';
+import { getLabel, noNaN, AudioRecorder, EventEmitter } from '@apia/util';
+import { makeObservable, observable, action, toJS, makeAutoObservable } from 'mobx';
+import { observer } from 'mobx-react-lite';
+import { CollectorField, Collector } from '@apia/validations';
+import { uniqueId } from '@apia/notifications';
+import { FileIcon } from '@apia/icons';
+import { ApiaApi, makeApiaUrl, parseSuccessfulResponse } from '@apia/api';
+import axios from 'axios';
+
+const AutoscrollContainer = ({ children }) => {
+  const observer = useRef(null);
+  const unsuscribe = useRef(null);
+  const isFullScrolled = useRef(false);
+  const hasInited = useRef(false);
+  const ref = useCallback((el) => {
+    if (!el)
+      return;
+    if (!hasInited.current) {
+      hasInited.current = true;
+      el.scrollTo({
+        top: el.getBoundingClientRect().height,
+        behavior: "auto"
+      });
+      isFullScrolled.current = true;
+    }
+    observer.current?.disconnect();
+    unsuscribe.current?.();
+    observer.current = new MutationObserver(([mutation]) => {
+      if (mutation && mutation.target instanceof HTMLElement && mutation.target === el) {
+        if (isFullScrolled.current && mutation.target.scrollTop !== mutation.target.scrollHeight - mutation.target.offsetHeight) {
+          mutation.target.scrollTo({
+            top: mutation.target.scrollHeight,
+            behavior: "smooth"
+          });
+        }
+      }
+    });
+    observer.current.observe(el, { childList: true, subtree: true });
+    const handleScroll = (ev) => {
+      if (ev.target === el && el instanceof HTMLElement) {
+        setTimeout(() => {
+          isFullScrolled.current = Math.abs(el.scrollTop - (el.scrollHeight - el.offsetHeight)) < 150;
+        }, 100);
+      }
+    };
+    el.addEventListener("scroll", handleScroll);
+    unsuscribe.current = () => {
+      el.removeEventListener("scroll", handleScroll);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      ...getVariant("layout.common.components.autoscrollContainer"),
+      className: "autoscrollContainer",
+      ref,
+      children
+    }
+  );
+};
+
+function isImageFile(file) {
+  const IMAGE_EXTENSIONS = [
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "bmp",
+    "webp",
+    "tiff",
+    "svg",
+    "jfif"
+  ];
+  return IMAGE_EXTENSIONS.includes(file.name.split(".").pop());
+}
+function getImageOcrMaker(lang) {
+  return new class ImageOcrMaker {
+    async processFile(file, onProgress) {
+      const tesseract = await import('tesseract.js');
+      const worker = await tesseract.createWorker(lang, 1, {
+        logger(arg) {
+          onProgress?.(arg.progress * 100);
+        }
+      });
+      const result = (await worker.recognize(file)).data.text;
+      return [result];
+    }
+    willProcessFile(file) {
+      return isImageFile(file);
+    }
+  }();
+}
+
+function isPdfFile(file) {
+  const IMAGE_EXTENSIONS = ["pdf"];
+  return IMAGE_EXTENSIONS.includes(file.name.split(".").pop());
+}
+function getPdfReader() {
+  return new class PdfReader {
+    async processFile(file, onProgress) {
+      onProgress?.(0);
+      const { getDocument, GlobalWorkerOptions } = await import('pdfjs-dist');
+      async function getPdfTextFromArrayBuffer(buffer) {
+        GlobalWorkerOptions.workerSrc = "../includes/pdf.worker.min.js";
+        const pdf = await getDocument({ data: buffer }).promise;
+        const pages = [];
+        for (let i = 1; i <= pdf.numPages; i++) {
+          const page = await pdf.getPage(i);
+          const textContent = await page.getTextContent();
+          pages.push(
+            textContent.items.map((item) => item.str).join(" ")
+          );
+        }
+        return pages;
+      }
+      return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = async function(event) {
+          if (!event.target?.result) {
+            alert("Error al leer el archivo.");
+            return;
+          }
+          const buffer = event.target.result;
+          const text = await getPdfTextFromArrayBuffer(buffer);
+          onProgress?.(100);
+          resolve(text);
+        };
+        reader.readAsArrayBuffer(file);
+      });
+    }
+    willProcessFile(file) {
+      return isPdfFile(file);
+    }
+  }();
+}
+
+class WrongFormatError extends Error {
+  constructor(fileName) {
+    super(`File format not supported: ${fileName}`);
+  }
+}
+function useHandleFileUpload({
+  onContent
+}) {
+  const [progress, setProgress] = useState(100);
+  const handleFileUpload = useCallback(
+    async (ev) => {
+      setProgress(0);
+      const imageProcessor = getImageOcrMaker("spa");
+      const pdfProcessor = getPdfReader();
+      await (async () => {
+        const obtainedText = [];
+        const files = ev.target.files;
+        const filesLength = ev.target.files?.length ?? 0;
+        if (files) {
+          for (let i = 0; i < filesLength; i++) {
+            const file = files[i];
+            if (!isImageFile(file) && !isPdfFile(file)) {
+              setProgress(100);
+              throw new WrongFormatError(file.name);
+            }
+            const handleProgress = (progress2) => {
+              setProgress(
+                i / filesLength * 100 + 1 / filesLength * 100 * (progress2 / 100)
+              );
+            };
+            let result = "";
+            if (imageProcessor.willProcessFile(file)) {
+              try {
+                result = (await imageProcessor.processFile(file, handleProgress))[0];
+              } catch (e) {
+                console.error(e);
+              }
+            } else if (pdfProcessor.willProcessFile(file)) {
+              result = (await pdfProcessor.processFile(file, handleProgress)).join("\n\n");
+            }
+            if (result) {
+              obtainedText.push(result);
+            }
+            setProgress((i + 1) / filesLength * 100);
+          }
+        }
+        onContent(obtainedText);
+      })();
+      ev.target.value = "";
+    },
+    [onContent]
+  );
+  return { progress, handleFileUpload };
+}
+
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => {
+  __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+let maxId = 0;
+class ChatMessage {
+  constructor(message = "", messageType = "user", attachments = [], reference = null) {
+    this.message = message;
+    this.messageType = messageType;
+    this.attachments = attachments;
+    this.reference = reference;
+    __publicField$a(this, "id");
+    __publicField$a(this, "copy", () => new ChatMessage(this.message, this.messageType, this.attachments));
+    __publicField$a(this, "Component", observer(() => {
+      return /* @__PURE__ */ jsxs(
+        Box,
+        {
+          as: "pre",
+          className: `history__message ${this.messageType}`,
+          children: [
+            /* @__PURE__ */ jsx(
+              Box,
+              {
+                className: "text_wrapper",
+                ...typeof this.message === "string" ? { dangerouslySetInnerHTML: { __html: this.message } } : { children: this.message }
+              }
+            ),
+            /* @__PURE__ */ jsx(Box, { className: "additionalContent_wrapper", children: this.attachments.map((x) => /* @__PURE__ */ jsx(x.Component, {}, x.getId())) }),
+            this.reference && /* @__PURE__ */ jsx(Box, { children: this.reference })
+          ]
+        },
+        this.id
+      );
+    }));
+    this.id = maxId++;
+    if (messageType === "response")
+      this.messageType = "system";
+    if (typeof message === "string")
+      this.message = this.parseMessage(message);
+    makeObservable(this, {
+      attachments: observable,
+      message: observable,
+      messageType: observable,
+      reference: observable
+    });
+  }
+  parseMessage(message) {
+    let result = message;
+    result = result.replaceAll("[strong]", "<strong>");
+    result = result.replaceAll("[/strong]", "</strong>");
+    return result;
+  }
+}
+
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => {
+  __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AIContent extends CollectorField {
+  constructor(content) {
+    super(uniqueId(), "");
+    __publicField$9(this, "type", "aiContent");
+    __publicField$9(this, "content");
+    __publicField$9(this, "Component", () => {
+      return /* @__PURE__ */ jsx(Box, { variant: "layout.common.components.aiMessage.textBox", children: /* @__PURE__ */ jsx(Box, { variant: "layout.common.components.aiMessage.textSnippet", children: this.content }) });
+    });
+    this.content = content;
+  }
+}
+
+const AIFileContentAllowedExtensions = {
+  svg: "svg",
+  png: "png",
+  jpg: "jpg",
+  jpeg: "jpeg",
+  txt: "txt",
+  doc: "doc",
+  pdf: "pdf",
+  docx: "docx",
+  csv: "csv",
+  xlsx: "xlsx",
+  xls: "xls",
+  mp3: "mp3",
+  wav: "wav"
+};
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2["DOCUMENT"] = "DOCUMENT";
+  FileType2["IMAGE"] = "IMAGE";
+  FileType2["AUDIO"] = "AUDIO";
+  FileType2["SHEET"] = "SHEET";
+  return FileType2;
+})(FileType || {});
+var AIMessageRole = /* @__PURE__ */ ((AIMessageRole2) => {
+  AIMessageRole2["USER"] = "USER";
+  AIMessageRole2["SYSTEM"] = "SYSTEM";
+  return AIMessageRole2;
+})(AIMessageRole || {});
+
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => {
+  __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _AIFileContent = class _AIFileContent extends AIContent {
+  constructor(fileUrl, fileName, f, error) {
+    const extension = _AIFileContent.getExtensionFromFileName(fileName);
+    super();
+    __publicField$8(this, "type");
+    __publicField$8(this, "fileUrl");
+    __publicField$8(this, "fileName");
+    __publicField$8(this, "extension");
+    __publicField$8(this, "__file");
+    __publicField$8(this, "__error");
+    __publicField$8(this, "overrideSize");
+    __publicField$8(this, "inferContent", () => {
+      return `You must collect information contained in this ${this.type} as help to build your tool choice.`;
+    });
+    __publicField$8(this, "inferExtension", (extension) => {
+      switch (extension) {
+        case AIFileContentAllowedExtensions.jpg:
+        case AIFileContentAllowedExtensions.jpeg:
+        case AIFileContentAllowedExtensions.png:
+        case AIFileContentAllowedExtensions.svg:
+          return FileType.IMAGE;
+        case AIFileContentAllowedExtensions.txt:
+        case AIFileContentAllowedExtensions.doc:
+        case AIFileContentAllowedExtensions.pdf:
+        case AIFileContentAllowedExtensions.docx:
+          return FileType.DOCUMENT;
+        case AIFileContentAllowedExtensions.csv:
+        case AIFileContentAllowedExtensions.xlsx:
+        case AIFileContentAllowedExtensions.xls:
+          return FileType.SHEET;
+        case AIFileContentAllowedExtensions.mp3:
+        case AIFileContentAllowedExtensions.wav:
+          return FileType.AUDIO;
+        default:
+          this.__throwError(
+            new Error(_AIFileContent.__getExtensionErrorMessage(extension)),
+            this.__error?.fileExtension
+          );
+      }
+    });
+    // COMPONENT METHODS
+    __publicField$8(this, "Component", () => /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          ...this.overrideSize ? {
+            ...this.overrideSize,
+            img: {
+              width: `${this.overrideSize.width - 20}px`,
+              height: `${this.overrideSize.height - 61}px`
+            }
+          } : {}
+        },
+        variant: "layout.common.components.aiMessage.fileBox",
+        children: [
+          FileType.IMAGE === this.type ? /* @__PURE__ */ jsx("img", { src: URL.createObjectURL(this.file), alt: this.fileName }) : /* @__PURE__ */ jsx(FileIcon, { iconSize: "lg", docName: this.fileName }),
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              as: "p",
+              variant: "layout.common.components.aiMessage.fileName",
+              title: this.fileName,
+              children: this.fileName
+            }
+          )
+        ]
+      }
+    ));
+    this.__error = error;
+    if (!_AIFileContent.isValidExtension(extension))
+      this.__throwError(
+        new Error(_AIFileContent.__getExtensionErrorMessage(extension)),
+        this.__error?.fileExtension
+      );
+    this.fileUrl = fileUrl;
+    this.extension = extension;
+    this.type = this.inferExtension(this.extension);
+    this.fileName = fileName;
+    this.__file = f;
+    this.content = this.inferContent();
+  }
+  // PUBLIC METHODS
+  setOverrideSize(overrideSize) {
+    this.overrideSize = overrideSize;
+    return this;
+  }
+  get file() {
+    if (!this.__file)
+      throw new Error("File is undefined");
+    return this.__file;
+  }
+  static getExtensionFromFileName(fileName) {
+    return fileName.split(".", 2).pop();
+  }
+  // PRIVATE METHODS
+  static __getExtensionErrorMessage(extension) {
+    return `extension "${extension}" is not included into valid types:
+${Object.keys(AIFileContentAllowedExtensions)}`;
+  }
+  __throwError(e, callback) {
+    callback && callback();
+    throw e;
+  }
+  getId() {
+    return uniqueId();
+  }
+};
+// STATIC METHODS
+__publicField$8(_AIFileContent, "isValidExtension", (extension) => {
+  return Object.values(
+    AIFileContentAllowedExtensions
+  ).includes(extension);
+});
+__publicField$8(_AIFileContent, "blobToBase64", async (blob) => {
+  return await ((blob2) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const base64String = reader.result;
+      resolve(base64String);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob2);
+  }))(blob);
+});
+__publicField$8(_AIFileContent, "fromFile", async (f, error) => {
+  const fileUrl = await ((f2) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(f2);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject();
+  }))(f);
+  return new _AIFileContent(fileUrl, f.name, f, error);
+});
+let AIFileContent = _AIFileContent;
+
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AIMessageAttachments {
+  constructor(role, content, close) {
+    this.close = close;
+    __publicField$7(this, "role");
+    __publicField$7(this, "content");
+    __publicField$7(this, "id", uniqueId());
+    __publicField$7(this, "customDescription", false);
+    __publicField$7(this, "addDescription", async () => {
+      const collector = new Collector();
+      const collected = await collector.add(this.content).add(
+        new collector.fields.textarea(
+          "addCommentTextArea",
+          getLabel("lblAiAddImageCo").text.replace(".", ""),
+          {
+            initialValue: this.content instanceof AIFileContent && this.content.content !== this.content.inferContent() ? this.content.content : ""
+          }
+        )
+      ).show({
+        title: getLabel("btnAddComment").text
+      }).catch((e) => {
+        throw e;
+      });
+      if (collected?.addCommentTextArea) {
+        this.content.content = collected.addCommentTextArea;
+        this.customDescription = true;
+      } else {
+        if (this.content instanceof AIFileContent)
+          this.content.content = this.content.inferContent();
+        this.customDescription = false;
+      }
+    });
+    __publicField$7(this, "Component", (props) => /* @__PURE__ */ jsxs(Box, { ...getVariant("layout.common.components.aiMessage"), children: [
+      props.closeButton ? /* @__PURE__ */ jsx(
+        IconButton,
+        {
+          className: "closeButton",
+          size: "Md",
+          icon: "Close",
+          onClick: this.close,
+          title: getLabel("lblDeleteItem").title
+        }
+      ) : /* @__PURE__ */ jsx(Fragment, {}),
+      props?.canAddDescription ? /* @__PURE__ */ jsx(
+        IconButton,
+        {
+          className: "descriptionButton",
+          size: "Md",
+          icon: "Magic",
+          onClick: this.addDescription
+        }
+      ) : /* @__PURE__ */ jsx(Fragment, {}),
+      /* @__PURE__ */ jsx(this.content.Component, {})
+    ] }));
+    this.role = role;
+    this.content = content;
+  }
+  getId() {
+    return this.id;
+  }
+}
+
+const handleFileUploadAsMessage = async (fileInputElement, chatController) => {
+  if (fileInputElement.files) {
+    [...fileInputElement.files].forEach(async (f) => {
+      const m = new AIMessageAttachments(
+        AIMessageRole.USER,
+        await AIFileContent.fromFile(f, {
+          fileExtension: () => chatController.messages.add(
+            new ChatMessage(
+              getLabel("msgAiIncorrectFileExtensionError", {
+                text: {
+                  TOK1: `[${Object.keys(AIFileContentAllowedExtensions).join(", ")}]`
+                }
+              }).text,
+              "error"
+            )
+          )
+        }),
+        () => chatController.attachments.drop(m)
+      );
+      chatController.attachments.add(m);
+    });
+  }
+};
+
+const makeTextarea = (chatController) => {
+  const NewTextarea = observer(
+    ({
+      hideDeleteButton,
+      isLoading: outIsLoading,
+      onSubmit,
+      preventAppendUserMessages
+    }) => {
+      const [isLoading, setIsLoading] = useState(false);
+      const breakpoint = useBreakpointIndex();
+      const submit = useCallback(() => {
+        if (preventAppendUserMessages !== true)
+          chatController.messages.add(chatController.state.current);
+        chatController.history.add(chatController.state.current);
+        onSubmit(chatController.state.current).finally(() => {
+          setIsLoading(false);
+          chatController.state.current = new ChatMessage();
+        });
+      }, [onSubmit, preventAppendUserMessages]);
+      const handleSubmit = useCallback(
+        (ev) => {
+          ev.preventDefault();
+          if (chatController.state.current.message || chatController.attachments.size() > 0) {
+            setIsLoading(true);
+            submit();
+          }
+          const textarea = document.getElementById(
+            `GPTMessage${chatController.id}`
+          );
+          textarea.focus();
+        },
+        [submit]
+      );
+      const onKeyDown = useCallback((ev) => {
+        if (ev.target.readOnly)
+          return;
+        if (ev.code === "Enter" && !ev.shiftKey) {
+          ev.preventDefault();
+          ev.target.closest("form")?.querySelector('button[type="submit"]')?.click();
+        }
+      }, []);
+      const { progress, handleFileUpload } = useHandleFileUpload({
+        onContent(content) {
+          document.getElementById(
+            `GPTMessage${chatController.id}`
+          ).value = content.join("\n\n");
+        }
+      });
+      const actualIsLoading = isLoading || progress !== 100 || outIsLoading;
+      const [dragging, setDragging] = useState(false);
+      const handleDragLeave = (ev) => {
+        ev.preventDefault();
+        setDragging(false);
+      };
+      const handleDrop = (ev) => {
+        ev.preventDefault();
+        setDragging(false);
+        const fileElement = document.getElementById(
+          `gptUploadFile__${chatController.id}`
+        );
+        fileElement.files = ev.dataTransfer.files;
+        const event = new Event("change", { bubbles: true });
+        fileElement.dispatchEvent(event);
+      };
+      const handleDragOver = (ev) => {
+        ev.preventDefault();
+      };
+      const handleDragEnter = (ev) => {
+        ev.preventDefault();
+        setDragging(true);
+      };
+      const additionalButtons = [];
+      additionalButtons.push({
+        key: "prev",
+        children: /* @__PURE__ */ jsx(
+          SimpleButton,
+          {
+            title: getLabel("btnAiPrevious").title,
+            variant: "outline",
+            type: "button",
+            onClick: chatController.history.previous,
+            size: "sm",
+            children: getLabel("btnAiPrevious").text
+          }
+        )
+      });
+      additionalButtons.push({
+        key: "next",
+        children: /* @__PURE__ */ jsx(
+          SimpleButton,
+          {
+            title: getLabel("btnAiNext").title,
+            variant: "outline",
+            type: "button",
+            onClick: chatController.history.next,
+            size: "sm",
+            children: getLabel("btnAiNext").text
+          }
+        )
+      });
+      if (!hideDeleteButton) {
+        additionalButtons.push({
+          key: "delete",
+          children: /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              title: getLabel("btnAiDelete").title,
+              variant: "outline",
+              type: "button",
+              onClick: () => {
+                chatController.state.current.message = "";
+                chatController.attachments.dropAll();
+                chatController.currentHistoryIndex = -1;
+              },
+              size: "sm",
+              children: getLabel("btnAiDelete").text
+            }
+          )
+        });
+        additionalButtons.push({
+          key: "deleteMessages",
+          children: /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              title: getLabel("btnAiDeleteMessages").title,
+              variant: "outline",
+              type: "button",
+              onClick: () => chatController.messages.clear(),
+              size: "sm",
+              children: getLabel("btnAiDeleteMessages").text
+            }
+          )
+        });
+      }
+      const isPhone = breakpoint < 4;
+      let iconButton = /* @__PURE__ */ jsx(Fragment, {});
+      if (isPhone) {
+        iconButton = /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            ...getVariant("layout.ai.execution.formsAssistant.settingsButton"),
+            iconSize: "Md",
+            size: "Lg",
+            icon: "Ellipsis",
+            isLoading: actualIsLoading,
+            onClick: () => {
+              const util = ApiaUtil.instance;
+              const items = [];
+              items.push(...additionalButtons);
+              if (items.length > 0)
+                util.menu.open({
+                  menuProps: {
+                    anchorPoint: { x: util.mouse.x, y: util.mouse.y }
+                  },
+                  items
+                });
+            }
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            sx: {
+              flexWrap: "wrap",
+              display: "flex",
+              maxHeight: "280px",
+              overflowY: "auto",
+              paddingTop: "6px",
+              paddingBottom: "6px"
+            },
+            children: chatController.attachments.getComponents()
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "form",
+          {
+            onDrop: handleDrop,
+            onDragOver: handleDragOver,
+            onDragEnter: handleDragEnter,
+            onDragLeave: handleDragLeave,
+            onSubmit: handleSubmit,
+            className: "gpt__form",
+            action: "",
+            children: [
+              dragging ? /* @__PURE__ */ jsx(
+                Box,
+                {
+                  sx: {
+                    height: "150px",
+                    border: "3px dashed #aaa",
+                    width: "100%",
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center"
+                  },
+                  children: getLabel("msgAiDragAndDrop").text
+                }
+              ) : /* @__PURE__ */ jsx(
+                Textarea,
+                {
+                  onKeyDown,
+                  id: `GPTMessage${chatController.id}`,
+                  readOnly: actualIsLoading,
+                  value: chatController.state.current.message,
+                  onChange: (ev) => {
+                    chatController.state.current.message = ev.target.value;
+                    if (!chatController.state.current.message && chatController.attachments.size() < 1)
+                      chatController.currentHistoryIndex = -1;
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsxs(Box, { className: "gpt__buttonsContainer", children: [
+                /* @__PURE__ */ jsx(Box, { sx: { display: "none" }, children: /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "file",
+                    className: "gptUploadFile",
+                    multiple: true,
+                    id: `gptUploadFile__${chatController.id}`,
+                    onChange: (ev) => {
+                      if (1 == noNaN("a"))
+                        handleFileUpload(ev).catch((e) => {
+                          if (e instanceof WrongFormatError) {
+                            setIsLoading(false);
+                            chatController.messages.add(
+                              new ChatMessage(
+                                getLabel("msgAiFileExtensionError").text,
+                                "error"
+                              )
+                            );
+                          } else {
+                            throw e;
+                          }
+                        });
+                      else {
+                        handleFileUploadAsMessage(ev.target, chatController);
+                      }
+                      ev.target.value = "";
+                    }
+                  }
+                ) }),
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    variant: "icon-outline",
+                    onClick: () => !chatController.audioRecorder.state.recording ? chatController.audioRecorder.start() : chatController.audioRecorder.stop(),
+                    disabled: actualIsLoading && !chatController.audioRecorder.state.recording,
+                    sx: {
+                      color: chatController.audioRecorder.state.recording ? "red" : void 0
+                    },
+                    icon: chatController.audioRecorder.state.recording ? "Stop" : "Microphone",
+                    id: "transcribeAudio",
+                    size: "Lg",
+                    title: getLabel("lblAiRecordAudio").text
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    title: getLabel("btnUploadFile").text,
+                    icon: "File",
+                    variant: "icon-outline",
+                    disabled: actualIsLoading,
+                    onClick: () => {
+                      document.getElementById(
+                        `gptUploadFile__${chatController.id}`
+                      ).click();
+                    },
+                    size: "Lg"
+                  }
+                ),
+                isPhone ? iconButton : /* @__PURE__ */ jsxs(Fragment, { children: [
+                  ...additionalButtons.map(
+                    (x) => x.children
+                  )
+                ] }),
+                /* @__PURE__ */ jsx(
+                  SimpleButton,
+                  {
+                    title: getLabel("btnAiSend").title,
+                    isLoading: actualIsLoading,
+                    type: "submit",
+                    size: "sm",
+                    children: getLabel("btnAiSend").text
+                  }
+                )
+              ] })
+            ]
+          }
+        )
+      ] });
+    }
+  );
+  NewTextarea.displayName = "";
+  return NewTextarea;
+};
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _promptsHistory, _internalAudioRecorder;
+class ChatController {
+  constructor(id, welcomeMessage) {
+    this.id = id;
+    __publicField$6(this, "state", {
+      current: new ChatMessage(),
+      messages: []
+    });
+    __publicField$6(this, "components", {
+      MessageHistory: observer(() => {
+        return /* @__PURE__ */ jsx(
+          Box,
+          {
+            ...getVariant("layout.common.components.chat"),
+            className: "history",
+            children: /* @__PURE__ */ jsx(AutoscrollContainer, { children: this.state.messages.map((current) => /* @__PURE__ */ jsx(current.Component, {}, current.id)) })
+          }
+        );
+      }),
+      Textarea: makeTextarea(this)
+    });
+    __privateAdd(this, _promptsHistory, []);
+    __publicField$6(this, "currentHistoryIndex", -1);
+    __privateAdd(this, _internalAudioRecorder, new AudioRecorder());
+    __publicField$6(this, "audioRecorder", {
+      start: () => __privateGet(this, _internalAudioRecorder).start().then(async (blob) => {
+        const m = new AIMessageAttachments(
+          AIMessageRole.USER,
+          new AIFileContent(
+            await AIFileContent.blobToBase64(blob),
+            `userRecord_${this.audioRecorder.record++}.wav`
+          ),
+          () => this.attachments.drop(m)
+        );
+        this.attachments.add(m);
+      }),
+      stop: async () => {
+        __privateGet(this, _internalAudioRecorder).stop();
+      },
+      record: 0,
+      state: __privateGet(this, _internalAudioRecorder).state
+    });
+    __publicField$6(this, "history", {
+      add: (message) => {
+        this.currentHistoryIndex = -1;
+        if (message === __privateGet(this, _promptsHistory)[__privateGet(this, _promptsHistory).length]) {
+          return;
+        }
+        __privateSet(this, _promptsHistory, [
+          message,
+          ...__privateGet(this, _promptsHistory).slice(
+            Math.max(0, __privateGet(this, _promptsHistory).length - 10)
+          )
+        ]);
+      },
+      next: () => {
+        let message = new ChatMessage();
+        if (__privateGet(this, _promptsHistory)[this.currentHistoryIndex - 1])
+          message = __privateGet(this, _promptsHistory)[--this.currentHistoryIndex].copy();
+        else {
+          this.currentHistoryIndex = -1;
+        }
+        this.history.updateState(message);
+      },
+      previous: () => {
+        if (__privateGet(this, _promptsHistory)[this.currentHistoryIndex + 1]) {
+          this.history.updateState(
+            __privateGet(this, _promptsHistory)[++this.currentHistoryIndex].copy()
+          );
+        }
+      },
+      updateState: (message) => {
+        if (message)
+          this.state.current = message;
+        else
+          this.state.current = new ChatMessage();
+      },
+      size: () => this.state.messages.length
+    });
+    __publicField$6(this, "messages", {
+      add: (message, idx) => {
+        if (idx !== void 0 && idx !== null) {
+          this.state.messages.splice(idx, 0, message);
+        } else {
+          this.state.messages.push(message);
+        }
+      },
+      clear: () => {
+        this.state.messages = [];
+      }
+    });
+    __publicField$6(this, "attachments", {
+      add: (...aiMessage) => {
+        this.state.current.attachments.push(...aiMessage);
+      },
+      dropAll: () => void (this.state.current.attachments = []),
+      drop: (el) => {
+        this.state.current.attachments = this.state.current.attachments.filter(
+          (c) => c !== el
+        );
+        if (!this.state.current.message && this.attachments.size() < 1)
+          this.currentHistoryIndex = -1;
+      },
+      getComponents: () => this.state.current.attachments.map((x) => /* @__PURE__ */ jsx(x.Component, { closeButton: true, canAddDescription: true }, x.getId())),
+      get: () => this.state.current.attachments,
+      size: () => this.state.current.attachments.length
+    });
+    if (welcomeMessage) {
+      this.state.messages.splice(
+        0,
+        0,
+        new ChatMessage(welcomeMessage, "system")
+      );
+    }
+    makeObservable(this, { state: observable });
+  }
+}
+_promptsHistory = new WeakMap();
+_internalAudioRecorder = new WeakMap();
+
+class MultipleChoiceMessage extends ChatMessage {
+  constructor(question, options, Renderer) {
+    super(
+      Renderer ? /* @__PURE__ */ jsxs(Box, { className: "multipleChoiceMessage customRenderer", children: [
+        /* @__PURE__ */ jsx(Paragraph, { children: question }),
+        options.map((item) => /* @__PURE__ */ jsx(Renderer, { item }, item.url))
+      ] }) : /* @__PURE__ */ jsxs(Box, { className: "multipleChoiceMessage", children: [
+        /* @__PURE__ */ jsx(Paragraph, { children: question }),
+        /* @__PURE__ */ jsx(Box, { as: "ul", children: options.map((current) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(
+          SimpleButton,
+          {
+            className: "multipleChoice__option",
+            onClick: () => {
+              ApiaUtil.instance.tabs.openTab(current.label, current.url);
+            },
+            children: current.label
+          }
+        ) }, current.label)) })
+      ] }),
+      "multipleChoice"
+    );
+  }
+}
+
+const Component = observer(
+  (props) => {
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx("a", { href: props.instance.state.link, children: props.instance.state.title }),
+      /* @__PURE__ */ jsx(Box, { children: props.instance.state.body })
+    ] });
+  }
+);
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SemanticSearchReference {
+  constructor(props) {
+    __publicField$5(this, "state", { title: "", body: "", link: "" });
+    __publicField$5(this, "Component", () => /* @__PURE__ */ jsxs(Fragment, { children: [
+      "(",
+      /* @__PURE__ */ jsx(Component, { instance: this }),
+      ")"
+    ] }));
+    this.state = props;
+    makeObservable(this, { state: observable });
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _SearchController = class _SearchController {
+  constructor() {
+    __publicField$4(this, "state", { queryString: "", results: [], isLoading: false, disabled: false });
+    makeObservable(this, { state: observable });
+  }
+  async search(selectedId) {
+    const filters = await FiltersStore.getFiltersById(
+      Number.parseInt(selectedId)
+    );
+    FiltersStore.setFilters(filters, "U");
+    _SearchController.instance.state.isLoading = true;
+    const response = await ApiaApi.post(
+      makeApiaUrl({
+        action: "search",
+        semSearchId: selectedId
+      }),
+      {
+        postData: {
+          q: _SearchController.instance.state.queryString,
+          filters: JSON.stringify(FiltersStore.getFiltersAsFilterValue("U"))
+        },
+        postDataTreatement: "stringify",
+        stringifyOptions: { arrayFormat: "repeat" }
+      }
+    );
+    if (response?.data?.results) {
+      this.setReferences(response.data.results);
+    }
+    this.state.isLoading = false;
+  }
+  setReferences(results) {
+    if (typeof results === "string" && results) {
+      results = JSON.parse(results);
+    }
+    _SearchController.instance.state.results = results.map(
+      (x) => x instanceof SemanticSearchReference ? x : new SemanticSearchReference(x)
+    );
+    _SearchController.instance.state.disabled = false;
+  }
+};
+__publicField$4(_SearchController, "instance", new _SearchController());
+let SearchController = _SearchController;
+var SearchController$1 = SearchController;
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function isPollProgress(payload) {
+  return payload?.progress !== void 0;
+}
+class RoutinesGeneration {
+  constructor() {
+    __publicField$3(this, "audioRecorder", new AudioRecorder());
+    __publicField$3(this, "routineId", "");
+    __publicField$3(this, "state", {
+      isLoading: false,
+      progress: 0
+    });
+    makeObservable(this, {
+      completion: action,
+      state: observable,
+      stop: action,
+      transcribeAudio: action
+    });
+  }
+  checkCanGenerate() {
+    if (this.state.isLoading) {
+      throw new Error("Cannot queue two simultaneous generations");
+    }
+    this.state.isLoading = true;
+  }
+  async pollRoutine(routineId, stream) {
+    this.routineId = routineId;
+    this.state.isLoading = true;
+    return this.internalPollRoutine(stream);
+  }
+  async internalPollRoutine(stream) {
+    while (this.state.isLoading) {
+      const pollResult = await this.callRoutinePoll(this.routineId);
+      if (isPollProgress(pollResult.payload)) {
+        try {
+          const res = JSON.parse(pollResult.payload.debug);
+          if (res.length > 0) {
+            res.forEach((c) => {
+              console.log(JSON.parse(c));
+            });
+          }
+          if (pollResult.payload.streamPart && stream) {
+            stream.emit("part", pollResult.payload.streamPart);
+          }
+          this.state.progress = pollResult.payload.progress;
+        } catch (e) {
+          console.error(e);
+        }
+      } else if (pollResult.status === "FINISHED") {
+        this.resetLoading();
+        return pollResult.payload;
+      } else if (pollResult.status === "ERROR") {
+        this.resetLoading();
+        throw new Error(pollResult.payload);
+      } else {
+        this.resetLoading();
+        throw new Error("Wrong poll response");
+      }
+    }
+    return null;
+  }
+  async callAudioTranscription(audio) {
+    const url = makeApiaUrl({
+      action: "routineStart",
+      routine: "transcription/Transcribe"
+    });
+    const response = await axios.post(url, audio.arrayBuffer(), {
+      headers: {
+        "Content-Type": "application/octet-stream"
+      }
+    });
+    const result = await parseSuccessfulResponse(response, "");
+    if (result?.orchestrator) {
+      return result;
+    }
+    return null;
+  }
+  async callRoutinePoll(routineId) {
+    const result = await ApiaApi.post(
+      makeApiaUrl({
+        action: "routinePoll",
+        routineId
+      })
+    );
+    if (result?.data?.orchestrator) {
+      return JSON.parse(result.data.orchestrator);
+    } else {
+      throw new Error("Poll failed");
+    }
+  }
+  async callRoutineStart(routineName, parameters, images) {
+    const result = await ApiaApi.post(
+      makeApiaUrl({
+        action: "routineStart",
+        routine: routineName
+      }),
+      {
+        postData: {
+          images: JSON.stringify(images),
+          ...parameters
+        },
+        stringifyOptions: {
+          arrayFormat: "repeat"
+        },
+        postDataTreatement: "stringify"
+      }
+    );
+    return result?.data || null;
+  }
+  async executeRoutine(routineName, parameters, images, stream) {
+    this.checkCanGenerate();
+    try {
+      const result = await this.callRoutineStart(
+        routineName,
+        parameters,
+        images
+      );
+      if (result?.orchestrator?.routineId !== void 0) {
+        this.routineId = result?.orchestrator.routineId;
+        return this.internalPollRoutine(stream);
+      } else {
+        throw new Error("Cannot get routine id");
+      }
+    } catch (e) {
+      this.resetLoading();
+      throw e;
+    }
+  }
+  resetLoading() {
+    this.state.isLoading = false;
+    this.state.progress = 0;
+  }
+  async completion(params) {
+    return this.executeRoutine(
+      params.routineName,
+      params.parameters ?? {},
+      params.images ?? [],
+      params.stream
+    );
+  }
+  stop() {
+    this.resetLoading();
+    ApiaApi.get(
+      makeApiaUrl({
+        action: "routineStop",
+        routineId: this.routineId
+      })
+    );
+  }
+  async transcribeAudio(audio) {
+    const result = await this.callAudioTranscription(audio);
+    if (result) {
+      this.state.isLoading = true;
+      if (result?.orchestrator?.routineId) {
+        this.routineId = result?.orchestrator?.routineId;
+        return await this.internalPollRoutine();
+      }
+    }
+    throw new Error("Something went wrong while transcribing the audio");
+  }
+}
+
+class DashboardsRoutinesGeneration extends RoutinesGeneration {
+  constructor(dispatcher) {
+    super();
+    this.dispatcher = dispatcher;
+  }
+  blobToBase64(audio) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        if (reader.result && typeof reader.result === "string") {
+          const base64 = reader.result.split(",")[1];
+          resolve(base64);
+        } else {
+          reject(new Error("Could not convert Blob to base64"));
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(audio);
+    });
+  }
+  async callAudioTranscription(audio) {
+    const audioBase64 = await this.blobToBase64(audio);
+    const result = await this.dispatcher({
+      action: "transcription",
+      audioBase64
+    });
+    return result?.data || null;
+  }
+  async callRoutinePoll(routineId) {
+    const result = await this.dispatcher({
+      action: "routinePoll",
+      routineId
+    });
+    if (result?.data?.orchestrator) {
+      const parsed = JSON.parse(result.data.orchestrator);
+      return parsed;
+    }
+    throw new Error("Poll failed");
+  }
+  async callRoutineStart(routineName, parameters, images) {
+    const result = await this.dispatcher({
+      action: "routineStart",
+      routine: routineName,
+      ...parameters,
+      images
+    });
+    return result?.data || null;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ResponseStream extends EventEmitter {
+  constructor() {
+    super(...arguments);
+    __publicField$2(this, "buffer", "");
+    __publicField$2(this, "isRunning", false);
+    __publicField$2(this, "locked", false);
+    __publicField$2(this, "maxCompletionTime", 2);
+    // s
+    __publicField$2(this, "minPartSize", 2);
+    __publicField$2(this, "partSize", 2);
+    __publicField$2(this, "timing", 5);
+    // ms
+    __publicField$2(this, "waiting", []);
+  }
+  calculatePartSize() {
+    const totalSize = this.buffer.length + this.waiting.reduce((a, b) => a + b.length, 0);
+    this.partSize = Math.max(
+      this.minPartSize,
+      totalSize * this.timing / (this.maxCompletionTime * 1e3)
+    );
+  }
+  emit(_, data) {
+    if (this.locked) {
+      this.waiting.push(data);
+    } else {
+      this.buffer += data;
+    }
+    this.calculatePartSize();
+    this.run();
+  }
+  run() {
+    if (!this.isRunning) {
+      this.isRunning = true;
+      const interval = setInterval(() => {
+        this.locked = true;
+        const choosedSize = Math.min(this.buffer.length, this.partSize);
+        const part = this.buffer.slice(0, choosedSize);
+        this.buffer = this.buffer.slice(choosedSize);
+        while (this.waiting.length > 0) {
+          const part2 = this.waiting.shift();
+          if (part2) {
+            this.buffer += part2;
+          }
+        }
+        this.locked = false;
+        if (part) {
+          super.emit("part", part);
+        } else {
+          this.isRunning = false;
+          clearInterval(interval);
+        }
+      }, this.timing);
+    }
+  }
+}
+
+async function getImageFromDisk(inputProps) {
+  return (await getImagesFromDisk({ ...inputProps, multiple: "false" }))[0] ?? null;
+}
+function getImagesFromDisk(inputProps) {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.accept = "image/*";
+    input.type = "file";
+    input.style.display = "none";
+    Object.assign(input, inputProps);
+    document.body.append(input);
+    input.addEventListener("change", (event) => {
+      const target = event?.target;
+      if (!target?.files)
+        return;
+      const retrievedImages = [];
+      const sources = [...target.files ?? []];
+      const checkResolve = () => {
+        if (sources.length === retrievedImages.length) {
+          resolve(retrievedImages.filter((c) => !!c));
+        }
+      };
+      sources.forEach((file) => {
+        if (file) {
+          const reader = new FileReader();
+          reader.onload = function(e) {
+            const binary = e.target?.result?.split(",")[1];
+            input.remove();
+            retrievedImages.push({
+              base64: binary,
+              path: file.name
+            });
+            checkResolve();
+          };
+          reader.readAsDataURL(file);
+        } else {
+          retrievedImages.push(null);
+        }
+        checkResolve();
+      });
+    });
+    input.click();
+  });
+}
+
+const ImageIcon = ({
+  deletable,
+  onClick,
+  onRemove,
+  src
+}) => {
+  return /* @__PURE__ */ jsxs(Box, { className: "image_preview", children: [
+    deletable && /* @__PURE__ */ jsx(IconButton, { icon: "Close", size: "Xs", iconSize: "Xs", onClick: onRemove }),
+    /* @__PURE__ */ jsx("img", { src, onClick })
+  ] });
+};
+
+function getSrcFromBase64(base64) {
+  return `data:image/jpg;base64,${base64}`;
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ImagesStore {
+  constructor(images, multiple) {
+    this.multiple = multiple;
+    __publicField$1(this, "images", /* @__PURE__ */ new Map());
+    __publicField$1(this, "selectedId", "");
+    this.images = new Map(
+      images.map((c) => {
+        const id = uniqueId();
+        return [id, { ...c, id }];
+      })
+    );
+    this.selectedId = this.images.values().next().value.id;
+    makeAutoObservable(this);
+  }
+}
+const GetImagesDescription = observer(({ store }) => {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: "images_description_generator",
+      ...getVariant("layout.design.projectAnalysis.imagesLoader"),
+      children: [
+        /* @__PURE__ */ jsx(Box, { className: "images_sort_wrapper", children: /* @__PURE__ */ jsx(
+          SortableList,
+          {
+            onSortChange: (ev) => {
+              store.images = new Map(
+                ev.map((c) => [
+                  c.props.id,
+                  c.props.additionalProps
+                ])
+              );
+            },
+            children: [...store.images].map(([k, c]) => /* @__PURE__ */ jsx(SortableListItem, { additionalProps: c, id: c.id, children: /* @__PURE__ */ jsx(
+              ImageIcon,
+              {
+                deletable: store.multiple,
+                onClick: () => {
+                  store.selectedId = c.id;
+                },
+                onRemove: () => {
+                  store.images.delete(k);
+                },
+                src: getSrcFromBase64(c.base64 ?? "")
+              }
+            ) }, c.id))
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(Box, { className: "image_editor", children: [
+          /* @__PURE__ */ jsx(Box, { className: "image_preview", children: store.images.get(store.selectedId) && /* @__PURE__ */ jsx(
+            "img",
+            {
+              src: getSrcFromBase64(
+                store.images.get(store.selectedId).base64 ?? ""
+              )
+            }
+          ) }),
+          /* @__PURE__ */ jsxs(Box, { className: "image_description", children: [
+            /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                autoFocus: true,
+                disabled: !store.images.get(store.selectedId),
+                onChange: (ev) => {
+                  const image = store.images.get(store.selectedId);
+                  if (image)
+                    image.description = ev.target.value;
+                },
+                value: store.images.get(store.selectedId)?.description
+              }
+            ),
+            store.multiple && /* @__PURE__ */ jsx(
+              IconButton,
+              {
+                icon: "Attach",
+                onClick: () => {
+                  getImagesFromDisk({ multiple: "true" }).then((res) => {
+                    res.forEach((c) => {
+                      const id = uniqueId();
+                      store.images.set(id, {
+                        base64: c.base64,
+                        description: "",
+                        id
+                      });
+                    });
+                  });
+                },
+                size: "Md",
+                iconSize: "Sm",
+                variant: "icon-only"
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  );
+});
+function getImagesWithDescription({
+  multiple
+}) {
+  return new Promise((resolve) => {
+    getImagesFromDisk({ multiple: multiple ? "true" : void 0 }).then(
+      (images) => {
+        const store = new ImagesStore(
+          images.map((c) => ({
+            base64: c.base64,
+            description: ""
+          })),
+          multiple || false
+        );
+        ApiaUtil.instance.modals.open({
+          children: /* @__PURE__ */ jsx(GetImagesDescription, { store }),
+          initialFocusGetter(modalInnerRef) {
+            return modalInnerRef.querySelector("textarea");
+          },
+          onConfirm: () => {
+            resolve([...toJS(store.images).values()]);
+          },
+          onCancel() {
+            resolve([]);
+          },
+          size: "xxxl-fixed",
+          noHeader: true
+        });
+      }
+    );
+  });
+}
+
+const ViewRendererContext = createContext(
+  {}
+);
+
+const Attachments = observer(
+  ({ attachments }) => {
+    return /* @__PURE__ */ jsx(Box, { children: attachments.map((x) => /* @__PURE__ */ jsx(x.Component, {})) });
+  }
+);
+
+const Header = observer(({ childComponent }) => {
+  return /* @__PURE__ */ jsx(Fragment, { children: childComponent });
+});
+
+const History = observer(({ messages }) => {
+  return /* @__PURE__ */ jsx(Box, { ...getVariant("layout.common.components.chat"), className: "history", children: /* @__PURE__ */ jsx(AutoscrollContainer, { children: messages.map((current) => /* @__PURE__ */ jsx(current.Component, {}, current.id)) }) });
+});
+
+const TextArea = observer(
+  ({
+    isLoading,
+    isRecording,
+    onSubmit,
+    onChange,
+    onClearHistory,
+    onClearAttachments,
+    onClearMessage,
+    onAttach,
+    onRecord,
+    onPrev,
+    onNext,
+    hideDeleteButton,
+    value,
+    //attachments,
+    id
+  }) => {
+    useBreakpointIndex();
+    const onKeyDown = useCallback((ev) => {
+      if (ev.target.readOnly)
+        return;
+      if (ev.code === "Enter" && !ev.shiftKey) {
+        ev.preventDefault();
+        ev.target.closest("form")?.querySelector('button[type="submit"]')?.click();
+      }
+    }, []);
+    const [dragging, setDragging] = useState(false);
+    const handleDragLeave = (ev) => {
+      ev.preventDefault();
+      setDragging(false);
+    };
+    const handleDrop = (ev) => {
+      ev.preventDefault();
+      setDragging(false);
+      const fileElement = document.getElementById(
+        `chatUploadFile__${id}`
+      );
+      fileElement.files = ev.dataTransfer.files;
+      const event = new Event("change", { bubbles: true });
+      fileElement.dispatchEvent(event);
+    };
+    const handleDragOver = (ev) => {
+      ev.preventDefault();
+    };
+    const handleDragEnter = (ev) => {
+      ev.preventDefault();
+      setDragging(true);
+    };
+    const additionalButtons = [];
+    additionalButtons.push({
+      key: "prev",
+      children: /* @__PURE__ */ jsx(
+        SimpleButton,
+        {
+          title: getLabel("btnAiPrevious").title,
+          variant: "outline",
+          type: "button",
+          onClick: onPrev,
+          size: "sm",
+          children: getLabel("btnAiPrevious").text
+        }
+      )
+    });
+    additionalButtons.push({
+      key: "next",
+      children: /* @__PURE__ */ jsx(
+        SimpleButton,
+        {
+          title: getLabel("btnAiNext").title,
+          variant: "outline",
+          type: "button",
+          onClick: onNext,
+          size: "sm",
+          children: getLabel("btnAiNext").text
+        }
+      )
+    });
+    if (!hideDeleteButton) {
+      additionalButtons.push({
+        key: "delete",
+        children: /* @__PURE__ */ jsx(
+          SimpleButton,
+          {
+            title: getLabel("btnAiDelete").title,
+            variant: "outline",
+            type: "button",
+            onClick: () => {
+              onClearMessage();
+              onClearAttachments();
+            },
+            size: "sm",
+            children: getLabel("btnAiDelete").text
+          }
+        )
+      });
+      additionalButtons.push({
+        key: "deleteMessages",
+        children: /* @__PURE__ */ jsx(
+          SimpleButton,
+          {
+            title: getLabel("btnAiDeleteMessages").title,
+            variant: "outline",
+            type: "button",
+            onClick: onClearHistory,
+            size: "sm",
+            children: getLabel("btnAiDeleteMessages").text
+          }
+        )
+      });
+    }
+    return /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          sx: {
+            flexWrap: "wrap",
+            display: "flex",
+            maxHeight: "280px",
+            overflowY: "auto",
+            paddingTop: "6px",
+            paddingBottom: "6px"
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "form",
+        {
+          onDrop: handleDrop,
+          onDragOver: handleDragOver,
+          onDragEnter: handleDragEnter,
+          onDragLeave: handleDragLeave,
+          onSubmit,
+          className: "gpt__form",
+          action: "",
+          children: [
+            dragging ? /* @__PURE__ */ jsx(
+              Box,
+              {
+                sx: {
+                  height: "150px",
+                  border: "3px dashed #aaa",
+                  width: "100%",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center"
+                },
+                children: getLabel("msgAiDragAndDrop").text
+              }
+            ) : /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                onKeyDown,
+                id: `chatMessage${id}`,
+                readOnly: isLoading,
+                value,
+                onChange: (ev) => {
+                  onChange(ev.target.value);
+                }
+              }
+            ),
+            /* @__PURE__ */ jsxs(Box, { className: "gpt__buttonsContainer", children: [
+              /* @__PURE__ */ jsx(Box, { sx: { display: "none" }, children: /* @__PURE__ */ jsx(
+                "input",
+                {
+                  type: "file",
+                  className: "gptUploadFile",
+                  multiple: true,
+                  id: `chatUploadFile__${id}`,
+                  onChange: (ev) => {
+                    onAttach(ev);
+                    ev.target.value = "";
+                  }
+                }
+              ) }),
+              /* @__PURE__ */ jsx(
+                IconButton,
+                {
+                  variant: "icon-outline",
+                  onClick: onRecord,
+                  disabled: isLoading && !isRecording,
+                  sx: {
+                    color: isRecording ? "red" : void 0
+                  },
+                  icon: isRecording ? "Stop" : "Microphone",
+                  id: "transcribeAudio",
+                  size: "Lg",
+                  title: getLabel("lblAiRecordAudio").text
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                IconButton,
+                {
+                  title: getLabel("btnUploadFile").text,
+                  icon: "File",
+                  variant: "icon-outline",
+                  disabled: isLoading,
+                  onClick: () => {
+                    document.getElementById(`gptUploadFile__${id}`).click();
+                  },
+                  size: "Lg"
+                }
+              ),
+              /* @__PURE__ */ jsxs(Fragment, { children: [
+                ...additionalButtons.map(
+                  (x) => x.children
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                SimpleButton,
+                {
+                  title: getLabel("btnAiSend").title,
+                  isLoading,
+                  type: "submit",
+                  size: "sm",
+                  children: getLabel("btnAiSend").text
+                }
+              )
+            ] })
+          ]
+        }
+      )
+    ] });
+  }
+);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ChatController2 {
+  constructor(props, onMessageSubmit, id) {
+    this.onMessageSubmit = onMessageSubmit;
+    this.id = id;
+    __publicField(this, "state", {
+      isLoading: false,
+      isRecording: false,
+      canRecord: true,
+      canAttach: true,
+      canAddSystemMessage: true,
+      hideDeleteButton: false,
+      canAddUserMessage: true,
+      maxAttachmentsSize: 100,
+      messages: [],
+      attachments: [],
+      currentMessage: ""
+    });
+    __publicField(this, "Header", () => {
+      return /* @__PURE__ */ jsx(Header, { childComponent: "" });
+    });
+    __publicField(this, "History", () => {
+      return /* @__PURE__ */ jsx(History, { messages: this.state.messages });
+    });
+    __publicField(this, "Attachments", () => {
+      return /* @__PURE__ */ jsx(Attachments, { attachments: this.state.attachments });
+    });
+    __publicField(this, "TextArea", observer(() => {
+      return /* @__PURE__ */ jsx(
+        TextArea,
+        {
+          id: this.id,
+          value: this.state.currentMessage,
+          isLoading: this.state.isLoading,
+          isRecording: this.state.isRecording,
+          onChange: (ev) => {
+            this.state.currentMessage = ev;
+          },
+          onSubmit: () => {
+            const message = new ChatMessage(
+              this.state.currentMessage,
+              "user",
+              this.state.attachments
+            );
+            if (this.state.canAddUserMessage) {
+              this.addMessage(message);
+            }
+            this.onMessageSubmit({
+              message,
+              attachments: this.state.attachments
+            });
+            this.state.attachments = [];
+            this.state.currentMessage = "";
+          },
+          onClearHistory: () => {
+            this.state.messages = [];
+          },
+          onClearAttachments: () => {
+            this.state.attachments = [];
+          },
+          onClearMessage: () => {
+            this.state.currentMessage = "";
+          },
+          onAttach: async (ev) => {
+            const attachments = await Promise.all(
+              [...ev.target.files ? ev.target.files : []].map(
+                (x) => AIFileContent.fromFile(x)
+              )
+            );
+            this.state.attachments.push(...attachments);
+          },
+          onRecord: () => {
+          },
+          onPrev: () => {
+          },
+          onNext: () => {
+          },
+          hideDeleteButton: this.state.hideDeleteButton
+        }
+      );
+    }));
+    __publicField(this, "Renderer", observer(() => {
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(this.Header, {}),
+        /* @__PURE__ */ jsx(this.History, {}),
+        /* @__PURE__ */ jsx(this.Attachments, {}),
+        /* @__PURE__ */ jsx(this.TextArea, {})
+      ] });
+    }));
+    this.state = Object.assign({}, this.state, props);
+    makeObservable(this, { state: observable });
+  }
+  addMessage(message) {
+    this.state.messages.push(message);
+  }
+}
+
+export { AIMessageAttachments, AutoscrollContainer, ChatController, ChatController2, ChatMessage, DashboardsRoutinesGeneration, MultipleChoiceMessage, ResponseStream, RoutinesGeneration, SearchController$1 as SearchController, SemanticSearchReference as SemanticSearchResult, ViewRendererContext, getImageFromDisk, getImagesFromDisk, getImagesWithDescription };
+//# sourceMappingURL=index.js.map