app/components/Ui/Input/Autocomplete.vue

<!--
Liste déroulante avec autocompletion, à placer dans un composant `UiForm`

@see https://vuetifyjs.com/en/components/autocompletes/#usage
-->

<template>
  <main>
    <!--suppress TypeScriptValidateTypes -->
    <v-autocomplete
        :model-value="modelValue"
        autocomplete="search"
        :items="items"
        :label="$t(fieldLabel)"
        :item-title="itemTitle"
        :item-value="itemValue"
        :no-filter="noFilter"
        :auto-select-first="autoSelectFirst"
        :multiple="multiple"
        :loading="isLoading"
        :return-object="returnObject"
        :search-input.sync="search"
        :prepend-icon="prependIcon"
        :error="error || !!fieldViolations"
        :error-messages="errorMessage || fieldViolations ? $t(fieldViolations) : ''"
        :rules="rules"
        :chips="chips"
        :hide-no-data="hideNoData"
        :no-data-text="isLoading ? $t('please_wait') : $t('no_result_matching_your_request')"
        :variant="variant"
        @update:model-value="onUpdate"
        @update:search="emit('update:search', $event)"
        @update:menu="emit('update:menu', $event)"
        @update:focused="emit('update:focused', $event)"
    >
      <template v-if="slotText" #item="data">
<!--        <v-list-item-content v-text="data.item.slotTextDisplay"></v-list-item-content>-->
      </template>
    </v-autocomplete>
  </main>
</template>

<script setup lang="ts">
import {computed} from "@vue/reactivity";
import type {ComputedRef, Ref} from "@vue/reactivity";
import {useFieldViolation} from "~/composables/form/useFieldViolation";
import ObjectUtils from "~/services/utils/objectUtils";
import type {AnyJson} from "~/types/data";
import type {PropType} from "@vue/runtime-core";

const props = defineProps({
  /**
   * v-model
   */
  modelValue: {
    type: [String, Number, Object, Array] as PropType<any>,
    required: false,
    default: null
  },
  /**
   * Nom de la propriété d'une entité lorsque l'input concerne cette propriété
   * - Utilisé par la validation
   * - Laisser null si le champ ne s'applique pas à une entité
   */
  field: {
    type: String,
    required: false,
    default: null
  },
  /**
   * Label du champ
   * Si non défini, c'est le nom de propriété qui est utilisé
   */
  label: {
    type: String,
    required: false,
    default: null
  },
  /**
   * Liste des éléments de la liste
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-items
   */
  items: {
    type: Array as PropType<Array<Object>>,
    required: false,
    default: () => []
  },
  /**
   * Définit si le champ est en lecture seule
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-readonly
   */
  readonly: {
    type: Boolean,
    required: false
  },
  /**
   * Le model est l'objet lui-même, et non pas son id (ou la propriété définie avec itemValue)
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-return-object
   */
  returnObject: {
    type: Boolean,
    default: false
  },
  /**
   * Autorise la sélection multiple
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-multiple
   */
  multiple: {
    type: Boolean,
    default: false
  },
  /**
   * Propriété de l'objet à utiliser comme label
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-item-title
   */
  itemTitle: {
    type: String,
    default: 'title'
  },
  /**
   * Propriété de l'objet à utiliser comme clé (et correspondant au v-model)
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-item-value
   */
  itemValue: {
    type: String,
    default: 'id'
  },
  /**
   * Icône de gauche
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-prepend-icon
   */
  prependIcon: {
    type: String
  },
  /**
   * Rends les résultats sous forme de puces
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-chips
   */
  chips: {
    type: Boolean,
    default: false
  },
  /**
   * Le contenu de la liste est en cours de chargement
   */
  isLoading: {
    type: Boolean,
    required: false,
    default: false
  },
  /**
   * Propriété de l'objet utilisé pour grouper les items ; laisser null pour ne pas grouper
   */
  group: {
    type: String,
    required: false,
    default: null
  },
  /**
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-hide-no-data
   */
  hideNoData: {
    type: Boolean,
    required: false,
    default: false
  },
  // TODO: c'est quoi?
  slotText: {
    type: Array,
    required: false,
    default: null
  },
  /**
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-no-filter
   */
  noFilter: {
    type: Boolean,
    default: false
  },
  /**
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-auto-select-first
   */
  autoSelectFirst: {
    type: Boolean,
    default: true
  },
  // TODO: c'est quoi?
  translate: {
    type: Boolean,
    default: false
  },
  /**
   * Règles de validation
   * @see https://vuetify.cn/en/components/forms/#validation-with-submit-clear
   */
  rules: {
    type: Array,
    required: false,
    default: () => []
  },
  /**
   * Le champ est-il actuellement en état d'erreur
   */
  error: {
    type: Boolean,
    required: false
  },
  /**
   * Si le champ est en état d'erreur, quel est le message d'erreur?
   */
  errorMessage: {
    type: String,
    required: false,
    default: null
  },
  /**
   * @see https://vuetifyjs.com/en/api/v-autocomplete/#props-variant
   */
  variant: {
    type: String as PropType<"filled" | "outlined" | "plain" | "underlined" | "solo" | "solo-inverted" | "solo-filled" | undefined>,
    required: false,
    default: 'filled'
  }
})

const i18n = useI18n()

const search: Ref<string|null> = ref(null)

const fieldLabel: string = props.label ?? props.field

const {fieldViolations, updateViolationState} = useFieldViolation(props.field)

const emit = defineEmits(['update:model-value', 'update:search', 'update:focused', 'update:menu'])

const onUpdate = (event: string) => {
  updateViolationState(event)
  emit('update:model-value', event)
}

/**
 * Items à afficher
 * TODO: à revoir
 */
const items: ComputedRef<Array<AnyJson>> = computed(() => {
  let _items: Array<any> = props.items
  return _items
  // if (props.group !== null) {
  //   _items = groupItems(props.items)
  // }
  //
  // return prepareGroups(_items)
})

/**
 * On construit l'Array à double entrée contenant les groups (headers) et les items
 * TODO: à revoir
 *
 * @param items
 */
const groupItems = (items: Array<any>): Array<Array<string>> => {
  const group = props.group as string | null
  if (group === null) {
    return items
  }

  const itemsByGroup: Array<Array<string>> = []
  let groupValue = null

  for (const item of items) {
    if (item) {
      groupValue = item[group]

      if (!itemsByGroup[groupValue]) {
        itemsByGroup[groupValue] = []
      }

      itemsByGroup[groupValue].push(item)
    }
  }

  return itemsByGroup
}

/**
 * Construction de l'Array JSON contenant toutes les propositions à afficher dans le select
 * TODO: à revoir
 *
 * @param groupedItems
 */
const prepareGroups = (groupedItems: Array<Array<string>>): Array<AnyJson> => {
  let finalItems: Array<AnyJson> = []

  for (const group in groupedItems) {

    // Si un groupe est présent, alors on créé le groupe options header
    if (group !== 'undefined') {
      finalItems.push({header: i18n.t(group as string)})
    }

    // On parcourt les items pour préparer les texts / slotTexts à afficher
    finalItems = finalItems.concat(groupedItems[group].map((item: any) => {
      return prepareItem(item)
    }))
  }
  return finalItems
}

/**
 * Construction d'un item
 * TODO: à revoir
 *
 * @param item
 */
const prepareItem = (item: Object): AnyJson => {
  const slotTextDisplay: Array<string> = []
  const itemTextDisplay: Array<string> = []

  item = ObjectUtils.cloneAndFlatten(item)

  // Si on souhaite avoir un texte différent dans les propositions que dans la sélection finale de select
  if (props.slotText) {
    for (const text of props.slotText) {
      slotTextDisplay.push(props.translate ? i18n.t(item[text as string]) : item[text as string])
    }
  }

  for (const text of props.itemTitle) {
    itemTextDisplay.push(props.translate ? i18n.t(item[text as string]) : item[text as string])
  }

  // On reconstruit l'objet
  return Object.assign({}, item, { itemTextDisplay: itemTextDisplay.join(' '), slotTextDisplay: slotTextDisplay.join(' ') })
}

</script>