@openk9ui/openk9-chatbot 3.0.1

package/dist/components/client.js

@@ -0,0 +1,119 @@
+import React__default from "react";
+const OpenK9ClientContext = React__default.createContext(
+  null
+  /* must break app if not provided */
+);
+function Client() {
+  return null;
+}
+function OpenK9Client({
+  callbackAuthorization
+}) {
+  async function authFetch(route, init = {}) {
+    const authorization = callbackAuthorization && callbackAuthorization();
+    const headers = {
+      ...init.headers,
+      ...authorization ? { authorization } : {}
+    };
+    return fetch(route, {
+      ...init,
+      headers
+    });
+  }
+  return {
+    // authInit: keycloakInit,
+    // async authenticate() {
+    // 	await keycloak.login();
+    // },
+    // async deauthenticate() {
+    // 	await keycloak.logout();
+    // },
+    // async getUserProfile(): Promise<{ name?: string } | undefined | null> {
+    // 	if (!keycloak.authenticated) {
+    // 		throw new Error("User is not authenticated");
+    // 	}
+    // 	try {
+    // 		const userInfo = await keycloak.loadUserInfo();
+    // 		return userInfo as { name: string };
+    // 	} catch (error) {
+    // 		throw error;
+    // 	}
+    // },
+    async getInitialMessages(chatId) {
+      const response = await authFetch(`/api/rag/chat/${chatId}`);
+      if (!response.ok) throw new Error("Network response was not ok");
+      const data = await response.json();
+      return data || [];
+    },
+    // async getUserInfo(): Promise<getUserInfo> {
+    // 	const response = await fetch(`/api/datasource/buckets/current`);
+    // 	if (!response.ok) throw new Error("Network response was not ok");
+    // 	const data = await response.json();
+    // 	return data;
+    // },
+    async getHistoryChat(searchQuery) {
+      console.log("Calling getHistoryChat with URL:", "/api/rag/user-chats");
+      const response = await authFetch(`/api/rag/user-chats`, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(searchQuery)
+      });
+      if (!response.ok) {
+        console.error("Response not ok:", response.status, response.statusText);
+        throw new Error("Network response was not ok");
+      }
+      const result = await response.json();
+      return result;
+    },
+    async GenerateResponse({
+      url,
+      searchQuery,
+      controller
+    }) {
+      const response = await authFetch(url, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(searchQuery),
+        signal: controller.signal
+      });
+      return response;
+    }
+    // async deleteChat(chatId: string) {
+    // 	const response = await authFetch(`/api/rag/chat/${chatId}`, {
+    // 		method: "DELETE",
+    // 		headers: {
+    // 			accept: "application/json"
+    // 		}
+    // 	});
+    // 	if (!response.ok) {
+    // 		throw new Error("Errore durante l'eliminazione della chat");
+    // 	}
+    // 	return response;
+    // },
+    // async renameChat(chatId: string, newTitle: string) {
+    // 	const response = await authFetch(`/api/rag/chat/${chatId}`, {
+    // 		method: "PATCH",
+    // 		headers: {
+    // 			accept: "application/json",
+    // 			"Content-Type": "application/json",
+    // 		},
+    // 		body: JSON.stringify({ newTitle })
+    // 	});
+    // 	if (!response.ok) {
+    // 		throw new Error("Errore durante la rinomina della chat");
+    // 	}
+    // 	return response;
+    // }
+  };
+}
+export {
+  OpenK9Client,
+  OpenK9ClientContext,
+  Client as default
+};

package/dist/components/styled.js

@@ -0,0 +1,21 @@
+import styled from "@emotion/styled";
+const ParagraphTime = styled.p`
+  color: ${(props) => props.$color};
+  margin: 0px;
+  align-self: end;
+  font-size: 10px;
+  font-weight: 500;
+  line-height: 11.72px;
+`;
+const ParagraphMessage = styled.p`
+    color:${(props) => props.$color};
+    margin: 0px;
+    fontSize: "12px",
+    fontWeight: "400",
+    lineHeight: "18.25px",
+    textAlign: "left",
+    `;
+export {
+  ParagraphMessage,
+  ParagraphTime
+};

package/dist/components/useFocusTrap.js

@@ -0,0 +1,95 @@
+import { useRef, useCallback, useEffect } from "react";
+function convertToIntOrFallback(stringToConvert) {
+  const parsed = parseInt(stringToConvert ?? "");
+  return isNaN(parsed) ? 0 : parsed;
+}
+function getTabIndexOfNode(targetNode) {
+  return convertToIntOrFallback(targetNode.getAttribute("tabindex"));
+}
+function sanitizeTabIndexInput(tabIndex, highestPositiveTabIndex) {
+  if (tabIndex < 0) {
+    throw new Error(
+      `Unable to sort given input. A negative value is not part of the tab order: ${tabIndex}`
+    );
+  }
+  return tabIndex === 0 ? highestPositiveTabIndex + 1 : tabIndex;
+}
+function sortByTabIndex(firstNode, secondNode) {
+  const tabIndexes = [firstNode, secondNode].map(
+    (node) => getTabIndexOfNode(node)
+  );
+  return tabIndexes.map(
+    (tabIndexValue) => sanitizeTabIndexInput(tabIndexValue, Math.max(...tabIndexes))
+  ).reduce((previousValue, currentValue) => previousValue - currentValue);
+}
+const focusableElementsSelector = "a[href], area[href], input:not([disabled]):not([type=hidden]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, *[tabindex], *[contenteditable]";
+const TAB_KEY = 9;
+function useFocusTrap(isActive) {
+  const trapRef = useRef(null);
+  const selectNextFocusableElem = useCallback(
+    (sortedFocusableElems, currentIndex, shiftKeyPressed = false, skipCount = 0) => {
+      if (skipCount > sortedFocusableElems.length) {
+        return;
+      }
+      const backwards = !!shiftKeyPressed;
+      const maxIndex = sortedFocusableElems.length - 1;
+      if (currentIndex === void 0) {
+        currentIndex = sortedFocusableElems.indexOf(document.activeElement) ?? 0;
+      }
+      let nextIndex = backwards ? currentIndex - 1 : currentIndex + 1;
+      if (nextIndex > maxIndex) {
+        nextIndex = 0;
+      }
+      if (nextIndex < 0) {
+        nextIndex = maxIndex;
+      }
+      const newFocusElem = sortedFocusableElems[nextIndex];
+      newFocusElem.focus();
+      if (document.activeElement !== newFocusElem) {
+        selectNextFocusableElem(
+          sortedFocusableElems,
+          nextIndex,
+          shiftKeyPressed,
+          skipCount + 1
+        );
+      }
+    },
+    []
+  );
+  const trapper = useCallback(
+    (evt) => {
+      const trapRefElem = trapRef.current;
+      if (trapRefElem !== null) {
+        if (evt.which === TAB_KEY || evt.key === "Tab") {
+          evt.preventDefault();
+          const shiftKeyPressed = !!evt.shiftKey;
+          let focusableElems = Array.from(
+            trapRefElem.querySelectorAll(focusableElementsSelector)
+          ).filter(
+            (focusableElement) => getTabIndexOfNode(focusableElement) >= 0
+          );
+          focusableElems = focusableElems.sort(sortByTabIndex);
+          selectNextFocusableElem(focusableElems, void 0, shiftKeyPressed);
+        }
+      }
+    },
+    [selectNextFocusableElem]
+  );
+  useEffect(() => {
+    if (isActive) {
+      window.addEventListener("keydown", trapper);
+    }
+    return () => {
+      if (isActive) {
+        window.removeEventListener("keydown", trapper);
+      }
+    };
+  }, [isActive, trapper]);
+  return [trapRef];
+}
+export {
+  convertToIntOrFallback,
+  getTabIndexOfNode,
+  sortByTabIndex,
+  useFocusTrap
+};

package/dist/components/useGenerateResponse.js

@@ -0,0 +1,271 @@
+import React__default, { useState, useCallback } from "react";
+import { useLanguage } from "./useLanguage.js";
+import { OpenK9Client } from "./client.js";
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  }
+  return getRandomValues(rnds8);
+}
+const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = { randomUUID };
+function v4(options, buf, offset) {
+  var _a;
+  if (native.randomUUID && true && !options) {
+    return native.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? ((_a = options.rng) == null ? void 0 : _a.call(options)) ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return unsafeStringify(rnds);
+}
+const useGenerateResponse = ({
+  initialMessages,
+  tenant,
+  callbackAuthorization
+}) => {
+  const { language } = useLanguage();
+  const [messages, setMessages] = useState(initialMessages);
+  const [abortControllers, setAbortControllers] = useState(/* @__PURE__ */ new Map());
+  const [isChatting, setIsChatting] = useState(false);
+  const [isLoading, setIsLoading] = useState(null);
+  const client = React__default.useMemo(
+    () => OpenK9Client({ callbackAuthorization }),
+    [callbackAuthorization]
+  );
+  const generateResponse = useCallback(
+    async (query) => {
+      var _a, _b;
+      const id = v4();
+      setIsLoading({ id, isLoading: true });
+      const timestamp = "" + Date.now();
+      const nonLoggedUserId = `anonymous_${v4()}_${timestamp}`;
+      const chatHistory = messages.map((msg) => ({
+        question: msg.question,
+        answer: msg.answer,
+        title: "",
+        sources: msg.sources || [],
+        chat_id: nonLoggedUserId,
+        //keycloak.authenticated ? chatId : nonLoggedUserId,
+        timestamp: msg.timestamp || "",
+        chat_sequence_number: msg.chat_sequence_number
+      }));
+      setMessages((prevMessages) => {
+        var _a2;
+        const chat_sequence_number = (((_a2 = prevMessages[prevMessages.length - 1]) == null ? void 0 : _a2.chat_sequence_number) || 0) + 1;
+        const newMessage = {
+          id,
+          question: query,
+          answer: "",
+          sendTime: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "CHUNK",
+          sources: [],
+          chat_sequence_number,
+          timestamp
+        };
+        return [...prevMessages, newMessage];
+      });
+      setIsChatting(true);
+      const controller = new AbortController();
+      setAbortControllers((prev) => new Map(prev).set(id, controller));
+      const url = `${tenant}/api/rag/chat-tool`;
+      const searchQuery = (
+        // keycloak.authenticated ? {
+        // 	searchText: query,
+        // 	chatId,
+        // 	chatSequenceNumber: messages[messages.length - 1]?.chat_sequence_number + 1 || 1,
+        // 	timestamp,
+        // // language,
+        // } :
+        {
+          searchText: query,
+          chatSequenceNumber: ((_a = messages[messages.length - 1]) == null ? void 0 : _a.chat_sequence_number) + 1 || 1,
+          timestamp,
+          chatHistory
+          // language,
+        }
+      );
+      try {
+        const response = await client.GenerateResponse({
+          controller,
+          searchQuery,
+          url
+        });
+        if (response.ok) {
+          const reader = (_b = response.body) == null ? void 0 : _b.getReader();
+          const decoder = new TextDecoder("utf-8");
+          let done = false;
+          let buffer = "";
+          while (!done && reader) {
+            const { value, done: readerDone } = await reader.read();
+            done = readerDone;
+            buffer += decoder.decode(value, { stream: true });
+            let boundaryIndex;
+            while ((boundaryIndex = buffer.indexOf("\n")) !== -1) {
+              const chunkStr = buffer.slice(0, boundaryIndex);
+              buffer = buffer.slice(boundaryIndex + 1);
+              if (chunkStr.trim().startsWith("data: ")) {
+                const dataStr = chunkStr.trim().slice(6);
+                try {
+                  const data = JSON.parse(dataStr);
+                  switch (data.type) {
+                    case "CHUNK":
+                      setMessages(
+                        (prev) => prev.map(
+                          (msg) => msg.id === id ? {
+                            ...msg,
+                            answer: msg.answer + data.chunk
+                          } : msg
+                        )
+                      );
+                      break;
+                    case "DOCUMENT":
+                      setMessages(
+                        (prev) => prev.map(
+                          (msg) => msg.id === id ? {
+                            ...msg,
+                            sources: [...(msg == null ? void 0 : msg.sources) ?? [], data.chunk]
+                          } : msg
+                        )
+                      );
+                      break;
+                    case "START":
+                      setIsLoading(null);
+                      break;
+                    case "ERROR":
+                      setMessages(
+                        (prev) => prev.map(
+                          (msg) => msg.id === id ? {
+                            ...msg,
+                            answer: data.chunk,
+                            status: "ERROR"
+                          } : msg
+                        )
+                      );
+                      setIsChatting(false);
+                      break;
+                    case "END":
+                      setMessages(
+                        (prev) => prev.map(
+                          (msg) => msg.id === id ? {
+                            ...msg,
+                            status: "END"
+                          } : msg
+                        )
+                      );
+                      setIsChatting(false);
+                      break;
+                    default:
+                      console.warn(
+                        "Tipo di chunk non riconosciuto:",
+                        data.type
+                      );
+                      break;
+                  }
+                } catch (e) {
+                  console.error("Errore nel parsing del JSON", e);
+                }
+              }
+            }
+          }
+        } else {
+          console.error("Errore nel generare la risposta");
+          setMessages(
+            (prev) => prev.map(
+              (msg) => msg.id === id ? {
+                ...msg,
+                status: "ERROR",
+                answer: (response == null ? void 0 : response.statusText) || "Error"
+              } : msg
+            )
+          );
+          setIsChatting(false);
+        }
+        setIsChatting(false);
+        setIsLoading(null);
+      } catch (error) {
+        console.error("Errore durante la richiesta", error);
+        setIsChatting(false);
+      }
+      setAbortControllers((prev) => {
+        const updated = new Map(prev);
+        updated.delete(id);
+        return updated;
+      });
+    },
+    [messages, client, tenant, language]
+    //loading, userInfo,
+  );
+  const cancelResponse = (id) => {
+    const controller = abortControllers.get(id);
+    if (controller) {
+      controller.abort();
+      setIsLoading(null);
+      setMessages(
+        (prev) => prev.map(
+          (msg) => msg.id === id ? {
+            ...msg,
+            status: "END",
+            answer: "La risposta è stata annullata"
+          } : msg
+        )
+      );
+      setAbortControllers((prev) => {
+        const updated = new Map(prev);
+        updated.delete(id);
+        return updated;
+      });
+      setIsChatting(abortControllers.size > 0);
+    } else {
+      console.warn(`No AbortController found for id: ${id}`);
+    }
+  };
+  const cancelAllResponses = () => {
+    abortControllers.forEach((controller) => {
+      controller.abort();
+    });
+    setMessages(
+      (prev) => prev.map(
+        (msg) => msg.status === "CHUNK" ? {
+          ...msg,
+          status: "END",
+          answer: msg.answer + "... La risposta è stata annullata"
+        } : msg
+      )
+    );
+    setAbortControllers(/* @__PURE__ */ new Map());
+    setIsChatting(false);
+    setIsLoading(null);
+  };
+  const resetMessage = () => {
+    setMessages([]);
+  };
+  return {
+    messages,
+    generateResponse,
+    cancelResponse,
+    cancelAllResponses,
+    isChatting,
+    isLoading,
+    resetMessage
+  };
+};
+export {
+  useGenerateResponse as default
+};

package/dist/components/useLanguage.js

@@ -0,0 +1,12 @@
+import { useContext } from "react";
+import LanguageContext from "./LanguageContext.js";
+const useLanguage = () => {
+  const context = useContext(LanguageContext);
+  if (!context) {
+    throw new Error("useLanguage must used to LanguageProvider");
+  }
+  return context;
+};
+export {
+  useLanguage
+};