@tekkare/auriga 0.2.3 → 0.2.5

package/dist/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "0.2.3"
+  "version": "0.2.5"
 }

package/dist/runtime/components/argAdvancedSearchBar.vue

@@ -75,7 +75,8 @@
               size="14"
               color="var(--medium)"
             />
-            {{ sugg.text }}
+            <span v-if="!highlightInput"> {{ sugg.text }} </span>
+            <span v-else v-html="highlightSearchInput(sugg.text)" />
           </p>
         </div>
         <div v-else-if="!loadingSuggs" class="sugg_container">
@@ -268,6 +269,10 @@ export default defineComponent({
     loadingSuggs: {
       type: Boolean,
       default: false
+    },
+    highlightInput: {
+      type: Boolean,
+      default: false
     }
   },
   emits: ["update:Value", "onClose"],
@@ -396,6 +401,632 @@ export default defineComponent({
         searchedWords.value = props.defaultInputs;
       }
     });
+    function highlightSearchInput(suggestion) {
+      const escapedInput = value.value.replace(
+        /[-\/\\^$*+?.()|[\]{}]/g,
+        "\\<script lang="ts">
+import {
+  onMounted,
+  onUpdated,
+  ref,
+  computed,
+  defineProps,
+  defineEmits,
+  watch,
+  defineComponent,
+} from "vue";
+import argIcon from "./argIcon.vue";
+import { useFuse } from "@vueuse/integrations/useFuse";
+interface Suggestion {
+  icon?: string;
+  text: string;
+}
+
+export default defineComponent({
+  name: "argAdvancedSearchBar",
+  components: { argIcon },
+  props: {
+    placeHolderValue: {
+      type: String,
+      default: "Type your search",
+    },
+    customShortcuts: {
+      type: Array<{ keyword: ""; value: ""; symbol: "" }>,
+      default: () => [],
+    },
+    defaultInputs: {
+      type: Array<{ type: ""; value: "" }>,
+      default: () => [],
+    },
+    suggestions: {
+      type: Array<Suggestion>,
+      default: null,
+    },
+    fuzzyThreshold: {
+      type: Number,
+      default: 0.5,
+    },
+    lang: {
+      type: String,
+      default: "en",
+      validator: (value: string) => {
+        return ["en", "fr", "es"].includes(value);
+      },
+    },
+    loadingSuggs: {
+      type: Boolean,
+      default: false,
+    },
+    highlightInput: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  emits: ["update:Value", "onClose"],
+  setup(props, { emit }) {
+    const typing = ref(false);
+    const shortcuts = ref([
+      { keyword: "and", value: "add the word", symbol: "+" },
+      { keyword: "or", value: "matches at least one word", symbol: "/" },
+      { keyword: "not", value: "exclude the word", symbol: "!" },
+    ]);
+    const hoverShortcut = ref("" as string);
+    const selectedShortcut = ref("+" as string);
+    const searchedWords = ref([] as any);
+    const closeIndex = ref();
+    const value = ref("" as string);
+    const selectedTag = ref();
+    const duplicate = ref([]);
+    const searchBar = ref();
+    const tagsSection = ref();
+    const shortcutIndex = ref(-1);
+    const removeSelected = ref(false as boolean);
+    const hoverTag = ref();
+    const showInfo = ref(false as boolean);
+    const showChangeType = ref(null as any);
+    const regexSearch =
+      /^[\s\.\+\/\!]|[\+\/\!\s][\s\.]+|[\s\.]+[\+\/\!\s]$|\s+[\+\/]|\s+$/g;
+    // regex to check whitespaces / symbols in input value to avoid duplicate search
+    // each alternative is seperated by |
+    // 1st alternative: the word begins with a space or a symbol
+    // 2nd alternative: the word begins with a combination of one or more spaces and symbols
+    // 3rd alternative: the word ends with one or more spaces or symbols
+    // 4th alternative: the word contains one or more spaces followed by symbols
+    // 5th alternative: the word ends with one or more spaces
+
+    const suggOpen = ref(false);
+    const optionIndex = ref(0);
+
+    const iconColor = computed(() => {
+      if (typing.value === true) {
+        return "var(--primary)";
+      } else return "var(--medium)";
+    });
+
+    const hasShortcut = computed(() => {
+      if (selectedShortcut.value.length > 0 || hoverShortcut.value.length > 0) {
+        return true;
+      } else return false;
+    });
+
+    const infoHeight = computed(() => {
+      if (showInfo.value === true) {
+        const infoSection = document.getElementById("info");
+        const shortcutSection = document.getElementById("shortcuts");
+        if (infoSection !== null && shortcutSection !== null) {
+          if (infoSection.offsetHeight > shortcutSection.offsetHeight) {
+            return true;
+          } else return false;
+        } else return false;
+      } else return false;
+    });
+
+    const notFound = {
+      fr: "Aucune suggestion n'a été trouvée",
+      en: "No suggestions were found",
+      es: "No se encontraron sugerencias",
+    };
+    const loaderText = {
+      fr: "Plus de suggestions en chargement",
+      en: "Loading more suggestions",
+      es: "cargando más sugerencias",
+    };
+
+    watch(value, (new_value: string) => {
+      typing.value = false;
+      if (new_value === "") {
+        hoverShortcut.value = "";
+        suggOpen.value = false;
+        optionIndex.value = 0;
+        document.removeEventListener("click", closeSugg);
+      } else {
+        suggOpen.value = true;
+        setTimeout(() => {
+          document.addEventListener("click", closeSugg);
+        }, 100);
+        for (let i = 0; i < shortcuts.value.length; i++) {
+          if (new_value.startsWith(shortcuts.value[i].symbol)) {
+            selectedShortcut.value = shortcuts.value[i].symbol;
+          }
+        }
+      }
+    });
+
+    watch(
+      () => typing.value,
+      () => {
+        if (!typing.value) {
+          document.removeEventListener("click", close);
+        } else
+          setTimeout(() => {
+            document.addEventListener("click", close);
+          }, 100);
+      }
+    );
+
+    // watch(selectedShortcut, (new_shortcut: string) => {
+    //   value.value = `${new_shortcut}`;
+    // });
+
+    watch(closeIndex, (new_index: number) => {
+      if (new_index > searchedWords.value.length) {
+        removeSelected.value = true;
+      } else removeSelected.value = false;
+    });
+
+    const wordsLength = computed(() => {
+      return searchedWords.value.length;
+    });
+
+    watch(wordsLength, (newSearched: []) => {
+      setTimeout(() => {
+        if (tagsSection.value.scrollWidth > 4) {
+          tagsSection.value.scrollLeft += tagsSection.value.scrollWidth;
+        }
+      }, 100);
+    });
+
+    onMounted(() => {
+      searchBar.value = document.getElementById("search_input");
+      tagsSection.value = document.getElementById("tags");
+      if (props.customShortcuts.length > 0) {
+        for (let i = 0; i < props.customShortcuts.length; i++) {
+          shortcuts.value.push(props.customShortcuts[i]);
+        }
+      }
+      if (props.defaultInputs.length > 0) {
+        for (let i = 0; i < props.defaultInputs.length; i++) {
+          addToSearch(
+            props.defaultInputs[i].type,
+            props.defaultInputs[i].value,
+            true
+          );
+        }
+        searchedWords.value = props.defaultInputs;
+      }
+    });
+    function highlightSearchInput(suggestion: string): string {
+      // Échappe les caractères spéciaux pour une utilisation dans une expression régulière
+      const escapedInput = value.value.replace(
+        /[-\/\\^$*+?.()|[\]{}]/g,
+        "\\$&"
+      );
+      // Crée une nouvelle RegExp avec la valeur de recherche, en ignorant la casse
+      const regex = new RegExp(escapedInput);
+      // Remplace la partie correspondante par un span avec du style
+      return suggestion.replace(
+        regex,
+        (match) =>
+          `<span style="color: var(--primary); font-weight: 700">${match}</span>`
+      );
+    }
+
+    function shortcutColor(shortcut: string) {
+      if (
+        shortcut === selectedShortcut.value ||
+        shortcut === hoverShortcut.value
+      ) {
+        return "var(--darkest)";
+      } else return "var(--white)";
+    }
+
+    function handleChangeType(searchIndex: number) {
+      showChangeType.value = searchIndex;
+      setTimeout(() => {
+        document.addEventListener("click", close);
+      }, 200);
+    }
+
+    function changeSearchType(searchIndex: number, option: string) {
+      searchedWords.value[searchIndex].type = option;
+      emit("update:Value", searchedWords.value);
+      showChangeType.value = null;
+    }
+
+    function shortcutSelect(dir: string) {
+      typing.value = true;
+      let index;
+      if (selectedShortcut.value.length > 0) {
+        index = shortcuts.value.findIndex(
+          (x) => x.symbol === selectedShortcut.value
+        );
+      } else {
+        index = shortcutIndex.value;
+      }
+      if (dir === "desc") {
+        if (index < shortcuts.value.length - 1) {
+          selectedShortcut.value = shortcuts.value[index + 1].symbol;
+          shortcutIndex.value += 1;
+        } else {
+          selectedShortcut.value = shortcuts.value[0].symbol;
+          shortcutIndex.value = 0;
+        }
+      } else {
+        if (index > 0) {
+          selectedShortcut.value = shortcuts.value[index - 1].symbol;
+          shortcutIndex.value -= 1;
+        } else {
+          selectedShortcut.value =
+            shortcuts.value[shortcuts.value.length - 1].symbol;
+          shortcutIndex.value = shortcuts.value.length - 1;
+        }
+      }
+      // searchBar.value.focus();
+    }
+
+    function addToSearch(
+      search: string,
+      textValue: string,
+      isDefault: boolean
+    ) {
+      searchedWords.value.push({ type: search, value: textValue });
+      closeIndex.value = searchedWords.value.length;
+      selectedTag.value = null;
+      if (!isDefault) {
+        emit("update:Value", searchedWords.value);
+      }
+      searchBar.value.focus();
+      resetSearch();
+    }
+    const options = computed(() => ({
+      fuseOptions: {
+        includeScore: true,
+        threshold: 0.5,
+      },
+    }));
+    const filterSuggestions = computed(() => {
+      if (value.value.replace(/[+/!]/g, "").length > 0) {
+        return props.suggestions
+          .filter((f) =>
+            useFuse(
+              value.value.replace(/[+/!]/g, ""),
+              props.suggestions.map((a) => a.text),
+              options.value
+            )
+              .results.value.map((a) => a.item)
+              .includes(f.text)
+          )
+          .slice(0, 50);
+      } else return props.suggestions.slice(0, 50);
+    });
+
+    function selectTag(index: number, direction: number) {
+      let nextTag;
+      if (direction === 0) {
+        nextTag = document.getElementById(`tag${index + 1}`);
+      } else {
+        nextTag = document.getElementById(`tag${index + 1}`);
+      }
+      if (direction === 1 && index === 0 && tagsSection.value.scrollLeft > 0) {
+        tagsSection.value.scrollLeft = 0;
+      }
+      if (direction === 0 && index === searchedWords.value.length - 1) {
+        tagsSection.value.scrollLeft += tagsSection.value.scrollWidth;
+      }
+
+      if (
+        searchedWords.value.length > 0 &&
+        index < searchedWords.value.length &&
+        index >= 0
+      ) {
+        selectedTag.value = index;
+        closeIndex.value = index;
+        if (direction > 0 && index > 2 && nextTag !== null) {
+          tagsSection.value.scrollLeft += nextTag.offsetWidth;
+        } else if (
+          direction === 0 &&
+          index < searchedWords.value.length - 2 &&
+          nextTag !== null
+        ) {
+          tagsSection.value.scrollLeft -= nextTag.offsetWidth;
+        }
+      }
+      if (index < 0) {
+        selectedTag.value = null;
+        closeIndex.value = searchedWords.value.length + 1;
+      }
+      if (index >= searchedWords.value.length) {
+        selectedTag.value = null;
+        closeIndex.value = index;
+      }
+      if (index > searchedWords.value.length + 1) {
+        selectedTag.value = null;
+        closeIndex.value = -1;
+      }
+    }
+
+    function resetSearch() {
+      value.value = "";
+    }
+
+    function getKeyword(keyword: string) {
+      let returnKeyword = "";
+      for (let i = 0; i < shortcuts.value.length; i++) {
+        if (keyword === shortcuts.value[i].symbol) {
+          returnKeyword = shortcuts.value[i].keyword;
+        }
+      }
+      return returnKeyword;
+    }
+
+    function addTag() {
+      suggOpen.value = false;
+      if (removeSelected.value === true) {
+        emptySearch();
+      } else if (
+        selectedTag.value !== null &&
+        selectedTag.value < searchedWords.value.length &&
+        selectedTag.value >= 0
+      ) {
+        removeTag(selectedTag.value);
+      } else {
+        if (optionIndex.value > 0) {
+          value.value = filterSuggestions.value[optionIndex.value - 1].text;
+          if (
+            searchedWords.value.filter(
+              (f: any) =>
+                f.value === filterSuggestions.value[optionIndex.value - 1].text
+            ).length > 0
+          ) {
+            setTimeout(() => {
+              suggOpen.value = false;
+              value.value = "";
+            });
+          }
+          // closeOnEnter.value = true;
+        }
+        let search: any;
+        let searchValue = "";
+        let arrayValues: any[];
+        arrayValues = [];
+        if (value.value.length > 0) {
+          searchValue = value.value.replace(regexSearch, "");
+          for (let i = 0; i < shortcuts.value.length; i++) {
+            if (value.value.startsWith(shortcuts.value[i].symbol)) {
+              search = shortcuts.value[i].keyword;
+              searchValue = value.value.replace(shortcuts.value[i].symbol, "");
+            }
+          }
+          if (selectedShortcut.value.length > 0 && search === undefined) {
+            search = getKeyword(selectedShortcut.value);
+          } else if (hoverShortcut.value.length > 0 && search === undefined) {
+            search = getKeyword(hoverShortcut.value);
+          } else if (search === undefined) {
+            search = "and";
+          }
+          if (value.value.includes(",")) {
+            arrayValues = value.value.split(",");
+          }
+        }
+        if (searchValue.length > 0 && arrayValues.length === 0) {
+          if (
+            searchedWords.value.filter((f: any) => f.value === searchValue)
+              .length === 0
+          ) {
+            addToSearch(search, searchValue, false);
+          } else {
+            handleDuplicate(searchValue);
+            value.value = "";
+          }
+        } else if (arrayValues.length > 0) {
+          for (let i = 0; i < arrayValues.length; i++) {
+            const arraySearchValue = arrayValues[i].replace(regexSearch, "");
+            if (arraySearchValue.length > 0) {
+              if (
+                searchedWords.value.filter(
+                  (f: any) => f.value === arraySearchValue
+                ).length === 0
+              ) {
+                addToSearch(search, arraySearchValue, false);
+              } else {
+                handleDuplicate(arraySearchValue);
+                value.value = "";
+              }
+            }
+          }
+        }
+      }
+    }
+
+    function handleDuplicate(tag: any) {
+      duplicate.value.push(tag);
+      setTimeout(() => (duplicate.value = []), 1000);
+    }
+
+    function emptySearch() {
+      searchedWords.value = [];
+      removeSelected.value = false;
+      closeIndex.value = null;
+      value.value = "";
+      searchBar.value.focus();
+      emit("update:Value", searchedWords.value);
+    }
+    function selectSugg(sugg: Suggestion) {
+      // closeOnEnter.value = true;
+      if (
+        searchedWords.value.find(
+          (a: { type: string; value: string }) => a.value === sugg.text
+        ) === undefined
+      ) {
+        value.value = sugg.text;
+        addTag();
+      } else {
+        suggOpen.value = false;
+        handleDuplicate(sugg.text);
+      }
+    }
+
+    function selectSearch(item: any) {
+      const searchValue = value.value.replace(regexSearch, "");
+      selectedShortcut.value = item.symbol;
+      if (searchValue.length > 0) {
+        if (
+          searchedWords.value.filter((f: any) => f.value === searchValue)
+            .length === 0
+        ) {
+          addToSearch(getKeyword(item.symbol), searchValue, false);
+        } else {
+          handleDuplicate(searchValue);
+          value.value = "";
+        }
+      }
+      searchBar.value.focus();
+      typing.value = false;
+    }
+
+    function removeTag(tagIndex: any) {
+      searchedWords.value.splice(tagIndex, 1);
+      emit("update:Value", searchedWords.value);
+      if (tagIndex > 0 && value.value.length === 0) {
+        selectedTag.value -= 1;
+      } else {
+        selectedTag.value = searchedWords.value.length;
+      }
+
+      closeIndex.value = selectedTag.value;
+      searchBar.value.focus();
+    }
+
+    function handleDelete() {
+      if (value.value.length === 0) {
+        removeTag(searchedWords.value.length - 1);
+      }
+    }
+
+    function changeDisplay() {
+      if (typing.value === true) {
+        close();
+      } else {
+        typing.value = true;
+        setTimeout(() => {
+          document.addEventListener("click", close);
+        }, 100);
+      }
+      searchBar.value.focus();
+    }
+    function selectOption(isDown: boolean) {
+      if (isDown) {
+        optionIndex.value =
+          optionIndex.value === filterSuggestions.value.length
+            ? filterSuggestions.value.length
+            : optionIndex.value + 1;
+      } else {
+        optionIndex.value =
+          optionIndex.value === 0
+            ? filterSuggestions.value.length
+            : optionIndex.value - 1;
+      }
+      const suggContainer = document.querySelector(".search_suggestions");
+      const selectedOption =
+        suggContainer?.querySelectorAll("p")[optionIndex.value - 1];
+
+      if (selectedOption) {
+        const containerHeight = suggContainer?.clientHeight;
+        const containerScrollTop = suggContainer?.scrollTop;
+        const optionTop = selectedOption?.offsetTop;
+        const optionHeight = selectedOption?.offsetHeight * 2;
+
+        if (optionTop < containerScrollTop) {
+          // Scroll up to the selected option
+          suggContainer.scrollTop = optionTop;
+        } else if (
+          optionTop + optionHeight >
+          containerHeight + containerScrollTop
+        ) {
+          // Scroll down to the selected option
+          suggContainer.scrollTop = optionTop + optionHeight - containerHeight;
+        }
+      }
+    }
+
+    function close() {
+      emit("onClose");
+      typing.value = false;
+      showChangeType.value = null;
+    }
+
+    function closeSugg() {
+      suggOpen.value = false;
+      optionIndex.value = 0;
+      document.removeEventListener("click", close);
+    }
+
+    return {
+      close,
+      changeDisplay,
+      handleDelete,
+      removeTag,
+      selectSearch,
+      emptySearch,
+      getKeyword,
+      handleDuplicate,
+      addTag,
+      resetSearch,
+      selectTag,
+      addToSearch,
+      shortcutColor,
+      shortcutSelect,
+      typing,
+      shortcuts,
+      hoverShortcut,
+      selectedShortcut,
+      searchedWords,
+      closeIndex,
+      value,
+      selectedTag,
+      duplicate,
+      searchBar,
+      tagsSection,
+      shortcutIndex,
+      removeSelected,
+      hoverTag,
+      showInfo,
+      regexSearch,
+      iconColor,
+      hasShortcut,
+      infoHeight,
+      suggOpen,
+      filterSuggestions,
+      selectOption,
+      optionIndex,
+      selectSugg,
+      showChangeType,
+      changeSearchType,
+      notFound,
+      loaderText,
+      handleChangeType,
+      highlightSearchInput,
+    };
+  },
+});
+</script>"
+      );
+      const regex = new RegExp(escapedInput);
+      return suggestion.replace(
+        regex,
+        (match) => `<span style="color: var(--primary); font-weight: 700">${match}</span>`
+      );
+    }
     function shortcutColor(shortcut) {
       if (shortcut === selectedShortcut.value || shortcut === hoverShortcut.value) {
         return "var(--darkest)";
@@ -718,7 +1349,8 @@ export default defineComponent({
       changeSearchType,
       notFound,
       loaderText,
-      handleChangeType
+      handleChangeType,
+      highlightSearchInput
     };
   }
 });

package/dist/runtime/components/argAdvancedSearchBar.vue.d.ts

@@ -113,6 +113,10 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    highlightInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }, {
     close: () => void;
     changeDisplay: () => void;
@@ -169,6 +173,7 @@ declare const _default: import("vue").DefineComponent<{
         es: string;
     };
     handleChangeType: (searchIndex: number) => void;
+    highlightSearchInput: (suggestion: string) => string;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:Value" | "onClose")[], "update:Value" | "onClose", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     placeHolderValue: {
         type: StringConstructor;
@@ -280,6 +285,10 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    highlightInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & {
     "onUpdate:Value"?: ((...args: any[]) => any) | undefined;
     onOnClose?: ((...args: any[]) => any) | undefined;
@@ -298,5 +307,6 @@ declare const _default: import("vue").DefineComponent<{
     suggestions: Suggestion[];
     fuzzyThreshold: number;
     loadingSuggs: boolean;
+    highlightInput: boolean;
 }, {}>;
 export default _default;

package/dist/runtime/components/argSearchInput.vue

@@ -55,7 +55,8 @@
             size="14"
             color="var(--medium)"
           />
-          {{ sugg.text }}
+          <span v-if="!highlightInput"> {{ sugg.text }} </span>
+          <span v-else v-html="highlightSearchInput(sugg.text)" />
         </p>
       </div>
       <div v-else-if="!loadingSuggs" class="sugg_container">
@@ -104,9 +105,13 @@ export default defineComponent({
     loadingSuggs: {
       type: Boolean,
       default: false
+    },
+    highlightInput: {
+      type: Boolean,
+      default: false
     }
   },
-  emits: ["update:Value", "submitSearch"],
+  emits: ["update:Value", "submitSearch", "selectSuggestion"],
   setup(props, { emit }) {
     const searchValue = ref("");
     const suggOpen = ref(false);
@@ -170,6 +175,256 @@ export default defineComponent({
         }
       }
     );
+    function highlightSearchInput(suggestion) {
+      const escapedInput = searchValue.value.replace(
+        /[-\/\\^$*+?.()|[\]{}]/g,
+        "\\<script lang="ts">
+import argIcon from "./argIcon.vue";
+import { useFuse } from "@vueuse/integrations/useFuse";
+import {
+  onMounted,
+  ref,
+  computed,
+  watch,
+  defineProps,
+  defineEmits,
+  defineComponent,
+} from "vue";
+interface Suggestion {
+  icon?: string;
+  text: string;
+}
+export default defineComponent({
+  name: "argSearchInput",
+  components: { argIcon },
+  props: {
+    placeHolderValue: {
+      type: String,
+      default: "Search here...",
+    },
+    defaultValue: {
+      type: String,
+      default: "",
+    },
+    suggestions: {
+      type: Array<Suggestion>,
+      default: null,
+    },
+    fuzzyThreshold: {
+      type: Number,
+      default: 0.5,
+    },
+    lang: {
+      type: String,
+      default: "en",
+      validator: (value: string) => {
+        return ["en", "fr", "es"].includes(value);
+      },
+    },
+    loadingSuggs: {
+      type: Boolean,
+      default: false,
+    },
+    highlightInput: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  emits: ["update:Value", "submitSearch", "selectSuggestion"],
+
+  setup(props, { emit }) {
+    const searchValue = ref("");
+    const suggOpen = ref(false);
+
+    const notFound = {
+      fr: "Aucune suggestion n'a été trouvée",
+      en: "No suggestions were found",
+      es: "No se encontraron sugerencias",
+    };
+    const loaderText = {
+      fr: "Plus de suggestions en chargement",
+      en: "Loading more suggestions",
+      es: "cargando más sugerencias",
+    };
+
+    const closeOnEnter = ref(false);
+
+    const optionIndex = ref(0);
+
+    function selectOption(isDown: boolean) {
+      if (isDown) {
+        optionIndex.value =
+          optionIndex.value === filterSuggestions.value.length
+            ? filterSuggestions.value.length
+            : optionIndex.value + 1;
+      } else {
+        optionIndex.value =
+          optionIndex.value === 0
+            ? filterSuggestions.value.length
+            : optionIndex.value - 1;
+      }
+      const suggContainer = document.querySelector(".search_suggestions");
+      const selectedOption =
+        suggContainer?.querySelectorAll("p")[optionIndex.value - 1];
+
+      if (selectedOption) {
+        const containerHeight = suggContainer?.clientHeight;
+        const containerScrollTop = suggContainer?.scrollTop;
+        const optionTop = selectedOption?.offsetTop;
+        const optionHeight = selectedOption?.offsetHeight * 2;
+
+        if (optionTop < containerScrollTop) {
+          // Scroll up to the selected option
+          suggContainer.scrollTop = optionTop;
+        } else if (
+          optionTop + optionHeight >
+          containerHeight + containerScrollTop
+        ) {
+          // Scroll down to the selected option
+          suggContainer.scrollTop = optionTop + optionHeight - containerHeight;
+        }
+      }
+    }
+
+    watch(
+      () => searchValue.value,
+      () => {
+        if (searchValue.value.length > 0 && props.suggestions !== null) {
+          if (!closeOnEnter.value) {
+            suggOpen.value = true;
+            setTimeout(() => {
+              document.addEventListener("click", closeSugg);
+            });
+          } else {
+            suggOpen.value = false;
+            document.removeEventListener("click", closeSugg);
+            closeOnEnter.value = false;
+          }
+        } else {
+          suggOpen.value = false;
+          document.removeEventListener("click", closeSugg);
+        }
+      }
+    );
+
+    watch(
+      () => suggOpen.value,
+      () => {
+        if (!suggOpen.value) {
+          optionIndex.value = 0;
+        }
+      }
+    );
+
+    function highlightSearchInput(suggestion: string): string {
+      // Échappe les caractères spéciaux pour une utilisation dans une expression régulière
+      const escapedInput = searchValue.value.replace(
+        /[-\/\\^$*+?.()|[\]{}]/g,
+        "\\$&"
+      );
+      // Crée une nouvelle RegExp avec la valeur de recherche, en ignorant la casse
+      const regex = new RegExp(escapedInput);
+      // Remplace la partie correspondante par un span avec du style
+      return suggestion.replace(
+        regex,
+        (match) =>
+          `<span style="color: var(--primary); font-weight: 700">${match}</span>`
+      );
+    }
+
+    const options = computed(() => ({
+      fuseOptions: {
+        includeScore: true,
+        threshold: props.fuzzyThreshold,
+      },
+    }));
+
+    const filterSuggestions = computed(() => {
+      return props.suggestions
+        .filter((f) =>
+          useFuse(
+            searchValue,
+            props.suggestions.map((a) => a.text),
+            options.value
+          )
+            .results.value.map((a) => a.item)
+            .includes(f.text)
+        )
+        .slice(0, 50);
+    });
+
+    const selectSugg = (sugg: Suggestion) => {
+      closeOnEnter.value = true;
+      searchValue.value = sugg.text;
+      emit("update:Value", searchValue.value);
+      emit("selectSuggestion", searchValue.value);
+    };
+
+    function closeSugg() {
+      suggOpen.value = false;
+    }
+
+    function openSugg() {
+      if (searchValue.value.length > 0) {
+        suggOpen.value = true;
+      }
+    }
+
+    onMounted(() => {
+      searchValue.value = props.defaultValue;
+    });
+
+    watch(
+      () => props.defaultValue,
+      (new_value: string) => {
+        searchValue.value = new_value;
+      }
+    );
+
+    function changeInput(event: any) {
+      searchValue.value = event.target.value;
+      emit("update:Value", searchValue.value);
+    }
+    function submitSearch() {
+      if (optionIndex.value > 0) {
+        closeOnEnter.value = true;
+        searchValue.value = filterSuggestions.value[optionIndex.value - 1].text;
+        emit("update:Value", searchValue.value);
+        emit("selectSuggestion", searchValue.value);
+      }
+      emit("submitSearch");
+    }
+
+    function clearValue() {
+      searchValue.value = "";
+      emit("update:Value", searchValue.value);
+    }
+
+    return {
+      searchValue,
+      changeInput,
+      submitSearch,
+      clearValue,
+      suggOpen,
+      openSugg,
+      filterSuggestions,
+      selectSugg,
+      selectOption,
+      optionIndex,
+      notFound,
+      loaderText,
+      highlightSearchInput,
+    };
+  },
+});
+</script>"
+      );
+      const regex = new RegExp(escapedInput);
+      return suggestion.replace(
+        regex,
+        (match) => `<span style="color: var(--primary); font-weight: 700">${match}</span>`
+      );
+    }
     const options = computed(() => ({
       fuseOptions: {
         includeScore: true,
@@ -189,6 +444,7 @@ export default defineComponent({
       closeOnEnter.value = true;
       searchValue.value = sugg.text;
       emit("update:Value", searchValue.value);
+      emit("selectSuggestion", searchValue.value);
     };
     function closeSugg() {
       suggOpen.value = false;
@@ -216,6 +472,7 @@ export default defineComponent({
         closeOnEnter.value = true;
         searchValue.value = filterSuggestions.value[optionIndex.value - 1].text;
         emit("update:Value", searchValue.value);
+        emit("selectSuggestion", searchValue.value);
       }
       emit("submitSearch");
     }
@@ -235,7 +492,8 @@ export default defineComponent({
       selectOption,
       optionIndex,
       notFound,
-      loaderText
+      loaderText,
+      highlightSearchInput
     };
   }
 });

package/dist/runtime/components/argSearchInput.vue.d.ts

@@ -41,6 +41,10 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    highlightInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }, {
     searchValue: import("vue").Ref<string>;
     changeInput: (event: any) => void;
@@ -62,7 +66,8 @@ declare const _default: import("vue").DefineComponent<{
         en: string;
         es: string;
     };
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:Value" | "submitSearch")[], "update:Value" | "submitSearch", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    highlightSearchInput: (suggestion: string) => string;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:Value" | "submitSearch" | "selectSuggestion")[], "update:Value" | "submitSearch" | "selectSuggestion", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     placeHolderValue: {
         type: StringConstructor;
         default: string;
@@ -101,15 +106,21 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    highlightInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & {
     "onUpdate:Value"?: ((...args: any[]) => any) | undefined;
     onSubmitSearch?: ((...args: any[]) => any) | undefined;
+    onSelectSuggestion?: ((...args: any[]) => any) | undefined;
 }, {
     lang: string;
     placeHolderValue: string;
     suggestions: Suggestion[];
     fuzzyThreshold: number;
     loadingSuggs: boolean;
+    highlightInput: boolean;
     defaultValue: string;
 }, {}>;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/auriga",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Aurgia is a UI kit developped by Tekkare",
   "license": "MIT",
   "type": "module",