@cnamts/synapse 1.0.4 → 1.0.6

package/src/components/DatePicker/composables/tests/useManualDateValidation.spec.ts

@@ -166,8 +166,8 @@ describe('useManualDateValidation', () => {
 
 	it('devrait appeler validateField avec les règles personnalisées', () => {
 		const date = new Date('2023-01-01')
-		const customRules = [{ type: 'custom', options: {} }]
-		const customWarningRules = [{ type: 'warning', options: {} }]
+		const customRules = [{ type: 'custom', options: { validate: () => true } }]
+		const customWarningRules = [{ type: 'warning', options: { validate: () => true } }]
 
 		mockIsDateComplete.mockReturnValue(true)
 		mockValidateDateFormat.mockReturnValue({ isValid: true, message: '' })
@@ -189,7 +189,15 @@ describe('useManualDateValidation', () => {
 
 		validateManualInput('01/01/2023')
 
-		expect(mockValidateField).toHaveBeenCalledWith(date, customRules, customWarningRules)
+		// Vérifier que validateField a été appelé
+		expect(mockValidateField).toHaveBeenCalled()
+		// Vérifier que le premier argument est la date attendue
+		expect(mockValidateField.mock.calls[0][0]).toBe(date)
+		// Vérifier la structure des règles sans comparer les références de fonctions
+		expect(mockValidateField.mock.calls[0][1][0].type).toBe('custom')
+		expect(typeof mockValidateField.mock.calls[0][1][0].options.validate).toBe('function')
+		expect(mockValidateField.mock.calls[0][2][0].type).toBe('warning')
+		expect(typeof mockValidateField.mock.calls[0][2][0].options.validate).toBe('function')
 	})
 
 	it('devrait retourner le résultat de validateField', () => {

package/src/components/DatePicker/composables/useDateInputEditing.ts

@@ -1,31 +1,36 @@
-// Pas besoin d'importer Ref car il n'est pas utilisé
+import { useKeyboardEvents } from './useKeyboardEvents'
+import {
+	formatDateInput as formatDateInputUtil,
+	getDateDescription as getDateDescriptionUtil,
+	type FormatDateInputResult,
+} from '../utils/dateFormattingUtils'
 
 /**
  * Options pour le composable useDateInputEditing
  */
 export interface DateInputEditingOptions {
-	// Format de date (ex: 'DD/MM/YYYY')
+	/**
+   * Format de date (ex: 'DD/MM/YYYY')
+   */
 	format: string
-	// Fonction pour mettre à jour la valeur d'affichage
+	/**
+   * Fonction pour mettre à jour la valeur d'affichage
+   */
 	updateDisplayValue: (value: string) => void
-	// Fonction pour mettre à jour l'attribut aria-label (pour l'accessibilité)
+	/**
+   * Fonction pour mettre à jour l'attribut aria-label (pour l'accessibilité)
+   */
 	updateAriaLabel?: (value: string) => void
-	// Caractère à utiliser pour les positions non remplies (défaut: '_')
+	/**
+   * Caractère à utiliser pour les positions non remplies
+   */
 	placeholderChar?: string
-	// Si true, utilise des caractères invisibles pour les lecteurs d'écran
+	/**
+   * Si true, utilise des caractères invisibles pour les lecteurs d'écran
+   */
 	accessiblePlaceholders?: boolean
 }
 
-/**
- * Résultat du formatage d'une date
- */
-export interface FormatDateInputResult {
-	// Valeur formatée
-	formatted: string
-	// Position du curseur après formatage
-	cursorPos: number
-}
-
 /**
  * Composable pour gérer l'édition manuelle des dates
  * Ce composable fournit des fonctions pour formater les dates pendant la saisie
@@ -44,162 +49,63 @@ export const useDateInputEditing = (options: DateInputEditingOptions) => {
 	} = options
 
 	/**
-	 * Formate une entrée de date en ajoutant les séparateurs appropriés
-	 *
-	 * @param input - Chaîne de caractères saisie
-	 * @param cursorPosition - Position actuelle du curseur
-	 * @returns Objet contenant la chaîne formatée et la nouvelle position du curseur
-	 */
-	const formatDateInput = (input: string, cursorPosition?: number): FormatDateInputResult => {
-		// Nettoyer l'entrée pour ne garder que les chiffres
-		let cleanedInput = input.replace(/[^\d]/g, '')
-
-		// Déterminer le séparateur utilisé dans le format
-		const separator = format.match(/[^DMY]/)?.[0] || '/'
-
-		// Calculer la position du curseur dans l'entrée nettoyée (sans séparateurs)
-		const inputBeforeCursor = input.substring(0, cursorPosition || 0)
-		const digitsBeforeCursor = inputBeforeCursor.replace(/[^\d]/g, '').length
+   * Détermine le séparateur utilisé dans le format
+   */
+	const separator = format.match(/[^DMY]/)?.[0] || '/'
 
-		// Extraire les groupes de chiffres du format (DD, MM, YYYY)
-		const digitGroups: string[] = []
-		let currentGroup = ''
-
-		for (const char of format) {
-			if (['D', 'M', 'Y'].includes(char.toUpperCase())) {
-				currentGroup += char
-			}
-			else if (currentGroup) {
-				digitGroups.push(currentGroup)
-				currentGroup = ''
-			}
-		}
-
-		// Ajouter le dernier groupe s'il existe
-		if (currentGroup) {
-			digitGroups.push(currentGroup)
-		}
-
-		// Calculer le nombre total de chiffres attendus dans le format
-		const expectedDigits = format.replace(/[^DMY]/g, '').length
+	/**
+   * Wrapper pour formatDateInput avec les options prédéfinies
+   */
+	const formatDateInput = (input: string, cursorPosition?: number): FormatDateInputResult => {
+		return formatDateInputUtil(input, format, {
+			cursorPosition,
+			placeholderChar,
+		})
+	}
 
-		// Limiter le nombre de chiffres saisis au nombre attendu
-		if (cleanedInput.length > expectedDigits) {
-			cleanedInput = cleanedInput.substring(0, expectedDigits)
+	/**
+   * Gère la suppression des séparateurs
+   */
+	const handleBackspace = (event: KeyboardEvent & { target: HTMLInputElement }): void => {
+		const input = event.target
+		if (!input.selectionStart || input.selectionStart !== input.selectionEnd) {
+			return
 		}
 
-		// Construire la chaîne formatée
-		let result = ''
-		let digitIndex = 0
-
-		// Parcourir les groupes de chiffres pour construire la date formatée
-		for (let groupIndex = 0; groupIndex < digitGroups.length; groupIndex++) {
-			const group = digitGroups[groupIndex]
-			const groupLength = group.length
-
-			// Ajouter les chiffres pour ce groupe
-			for (let j = 0; j < groupLength; j++) {
-				if (digitIndex < cleanedInput.length) {
-					result += cleanedInput[digitIndex]
-					digitIndex++
-				}
-				else {
-					// Utiliser le caractère de placeholder configuré pour les positions non remplies
-					result += placeholderChar
-				}
-			}
-
-			// Ajouter le séparateur après chaque groupe sauf le dernier
-			if (groupIndex < digitGroups.length - 1) {
-				result += separator
-			}
-		}
+		const cursorPos = input.selectionStart
+		const charBeforeCursor = input.value[cursorPos - 1]
 
-		// Calculer la nouvelle position du curseur
-		let newCursorPos = 0
-		let digitCount = 0
+		// Si le caractère avant le curseur n'est pas un chiffre
+		if (!/\d/.test(charBeforeCursor)) {
+			event.preventDefault()
 
-		// Parcourir le résultat formaté pour trouver la position du curseur
-		for (let i = 0; i < result.length && digitCount < digitsBeforeCursor; i++) {
-			newCursorPos++
-			if (/\d/.test(result[i])) {
-				digitCount++
-			}
-		}
+			const newValue = input.value.substring(0, cursorPos - 2) + input.value.substring(cursorPos)
+			updateDisplayValue(newValue)
 
-		return {
-			formatted: result,
-			cursorPos: Math.min(newCursorPos, result.length),
+			// Positionner le curseur après un court délai
+			setTimeout(() => {
+				const newCursorPos = cursorPos - 2
+				input.setSelectionRange(newCursorPos, newCursorPos)
+			}, 0)
 		}
 	}
 
 	/**
-	 * Gère l'événement keydown pour les touches spéciales
-	 *
-	 * @param event - Événement keydown
-	 */
-	const handleKeydown = (event: KeyboardEvent & { target: HTMLInputElement }): void => {
-		// Bloquer la saisie de caractères non numériques
-		// Autoriser uniquement : chiffres, touches de navigation, touches de modification et touches de contrôle
-		if (
-			// Si la touche n'est pas un chiffre
-			!/^\d$/.test(event.key)
-			// Et n'est pas une touche spéciale autorisée
-			&& ![
-				'Backspace', 'Delete', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown',
-				'Home', 'End', 'Tab', 'Escape', 'Enter',
-				'Control', 'Alt', 'Shift', 'Meta',
-			].includes(event.key)
-			// Et n'est pas une combinaison de touches (Ctrl+A, Ctrl+C, Ctrl+V, etc.)
-			&& !(event.ctrlKey || event.metaKey)
-		) {
-			// Empêcher la saisie de caractères non numériques
-			event.preventDefault()
-			return
-		}
-
-		// Gérer la suppression des séparateurs
+   * Gestionnaire d'événement keydown personnalisé
+   */
+	const onSpecialKeyDown = (event: KeyboardEvent & { target: HTMLInputElement }): void => {
 		if (event.key === 'Backspace') {
-			const input = event.target
-			if (!input.selectionStart || input.selectionStart !== input.selectionEnd) {
-				return
-			}
-
-			const cursorPos = input.selectionStart
-			const charBeforeCursor = input.value[cursorPos - 1]
-
-			if (!/\d/.test(charBeforeCursor)) {
-				// Si le caractère avant le curseur n'est pas un chiffre, on le supprime aussi
-				// et on supprime le chiffre avant le séparateur
-				event.preventDefault() // Empêcher le comportement par défaut
-
-				const newValue = input.value.substring(0, cursorPos - 2)
-					+ input.value.substring(cursorPos)
-
-				// Mettre à jour la valeur
-				updateDisplayValue(newValue)
-
-				// Positionner le curseur après un court délai
-				setTimeout(() => {
-					const newCursorPos = cursorPos - 2
-					input.setSelectionRange(newCursorPos, newCursorPos)
-				}, 0)
-			}
+			handleBackspace(event)
 		}
-
-		// Gérer les touches de direction pour éviter de se retrouver entre un séparateur et un chiffre
-		if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+		else if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+			// Handle arrow key navigation around separators
 			const input = event.target
 			const cursorPos = input.selectionStart || 0
 
-			// Déterminer le séparateur utilisé dans le format
-			const separator = format.match(/[^DMY]/)?.[0] || '/'
-
 			if (event.key === 'ArrowLeft' && cursorPos > 0) {
 				const charBeforeCursor = input.value[cursorPos - 1]
 
 				if (charBeforeCursor === separator) {
-					// Si on se déplace à gauche et qu'on rencontre un séparateur, sauter par-dessus
 					event.preventDefault()
 					input.setSelectionRange(cursorPos - 2, cursorPos - 2)
 				}
@@ -208,7 +114,6 @@ export const useDateInputEditing = (options: DateInputEditingOptions) => {
 				const charAtCursor = input.value[cursorPos]
 
 				if (charAtCursor === separator) {
-					// Si on se déplace à droite et qu'on rencontre un séparateur, sauter par-dessus
 					event.preventDefault()
 					input.setSelectionRange(cursorPos + 2, cursorPos + 2)
 				}
@@ -216,11 +121,16 @@ export const useDateInputEditing = (options: DateInputEditingOptions) => {
 		}
 	}
 
+	// Utiliser le composable commun pour la gestion des événements clavier
+	const keyboardEvents = useKeyboardEvents({
+		allowedCharacters: /^\d$/,
+		onKeyDown: onSpecialKeyDown,
+		separator,
+	})
+
 	/**
-	 * Gère l'événement paste pour formater correctement les dates collées
-	 *
-	 * @param event - Événement paste
-	 */
+   * Gère l'événement paste pour formater correctement les dates collées
+   */
 	const handlePaste = (event: ClipboardEvent): void => {
 		if (!event.clipboardData) return
 
@@ -254,7 +164,7 @@ export const useDateInputEditing = (options: DateInputEditingOptions) => {
 			const accessibleValue = formatted.replace(new RegExp(placeholderChar, 'g'), ' ')
 
 			// Créer un message descriptif pour le lecteur d'écran
-			const dateDescription = getDateDescription(accessibleValue, format)
+			const dateDescription = getDateDescription(accessibleValue)
 			updateAriaLabel(dateDescription)
 		}
 
@@ -265,61 +175,15 @@ export const useDateInputEditing = (options: DateInputEditingOptions) => {
 	}
 
 	/**
-	 * Crée une description accessible de la date pour les lecteurs d'écran
-	 *
-	 * @param dateStr - La chaîne de date à décrire
-	 * @param format - Le format de la date
-	 * @returns Une description de la date adaptée aux lecteurs d'écran
-	 */
-	const getDateDescription = (dateStr: string, format: string): string => {
-		// Si la chaîne est vide, retourner un message simple
-		if (!dateStr.trim()) {
-			return 'Aucune date saisie'
-		}
-
-		// Déterminer le séparateur utilisé dans le format
-		const separator = format.match(/[^DMY]/)?.[0] || '/'
-
-		// Extraire les parties de la date
-		const dateParts = dateStr.split(separator)
-		const formatParts = format.split(separator)
-
-		// Créer une description en fonction du format
-		let description = 'Date en cours de saisie: '
-
-		for (let i = 0; i < formatParts.length; i++) {
-			if (i >= dateParts.length) break
-
-			const part = dateParts[i].trim()
-			const formatPart = formatParts[i].charAt(0).toUpperCase()
-
-			// Ignorer les parties vides ou contenant uniquement des placeholders
-			if (!part || part.replace(new RegExp(placeholderChar, 'g'), '').length === 0) {
-				continue
-			}
-
-			switch (formatPart) {
-				case 'D':
-					description += `jour ${part}, `
-					break
-				case 'M':
-					description += `mois ${part}, `
-					break
-				case 'Y':
-					description += `année ${part}, `
-					break
-			}
-		}
-
-		// Supprimer la virgule finale si elle existe
-		return description.endsWith(', ')
-			? description.slice(0, -2)
-			: description
+   * Wrapper pour getDateDescription avec les options prédéfinies
+   */
+	const getDateDescription = (dateStr: string): string => {
+		return getDateDescriptionUtil(dateStr, format, placeholderChar)
 	}
 
 	return {
 		formatDateInput,
-		handleKeydown,
+		handleKeydown: keyboardEvents.handleKeyDown,
 		handlePaste,
 		getDateDescription,
 	}

package/src/components/DatePicker/composables/useKeyboardEvents.ts

@@ -0,0 +1,149 @@
+/**
+ * Composable pour centraliser la gestion des événements clavier
+ * Utilisé dans les différents composants de saisie de date
+ */
+
+/**
+ * Options pour la gestion des événements clavier
+ */
+export interface KeyboardEventsOptions {
+	/**
+   * Expression régulière pour les caractères autorisés
+   * Par défaut, seuls les chiffres sont autorisés
+   */
+	allowedCharacters?: RegExp
+	/**
+   * Fonction à appeler lors d'un appui sur une touche
+   * Appelée après la validation des caractères
+   */
+	onKeyDown?: (event: KeyboardEvent & { target: HTMLInputElement }) => void
+	/**
+   * Séparateur utilisé dans le format de date
+   * Utilisé pour gérer les touches de navigation
+   */
+	separator?: string
+}
+
+/**
+ * Composable pour gérer les événements clavier communs aux champs de date
+ *
+ * @param options - Options de configuration
+ * @returns Fonctions pour gérer les événements clavier
+ */
+export const useKeyboardEvents = (options: KeyboardEventsOptions = {}) => {
+	const {
+		allowedCharacters = /^\d$/,
+		onKeyDown,
+		separator = '/',
+	} = options
+
+	/**
+   * Liste des touches spéciales toujours autorisées
+   */
+	const SPECIAL_KEYS = [
+		'Backspace', 'Delete',
+		'ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown',
+		'Home', 'End', 'Tab', 'Escape', 'Enter',
+		'Control', 'Alt', 'Shift', 'Meta',
+	]
+
+	/**
+   * Traite les événements keydown en filtrant les caractères non autorisés
+   */
+	const handleKeyDown = (event: KeyboardEvent & { target: HTMLInputElement }): void => {
+		// Autoriser uniquement : caractères autorisés, touches spéciales et combinaisons de touches
+		if (
+			!allowedCharacters.test(event.key)
+			&& !SPECIAL_KEYS.includes(event.key)
+			&& !(event.ctrlKey || event.metaKey)
+		) {
+			event.preventDefault()
+			return
+		}
+
+		// Appeler le gestionnaire personnalisé s'il existe
+		if (onKeyDown) {
+			onKeyDown(event)
+		}
+	}
+
+	/**
+   * Gère la navigation autour des séparateurs
+   * Évite que le curseur se positionne entre un chiffre et un séparateur
+   */
+	const handleArrowKeys = (event: KeyboardEvent & { target: HTMLInputElement }): void => {
+		const input = event.target
+		const cursorPos = input.selectionStart || 0
+
+		if (event.key === 'ArrowLeft' && cursorPos > 0) {
+			const charBeforeCursor = input.value[cursorPos - 1]
+
+			if (charBeforeCursor === separator) {
+				event.preventDefault()
+				input.setSelectionRange(cursorPos - 2, cursorPos - 2)
+			}
+		}
+		else if (event.key === 'ArrowRight' && cursorPos < input.value.length) {
+			const charAtCursor = input.value[cursorPos]
+
+			if (charAtCursor === separator) {
+				event.preventDefault()
+				input.setSelectionRange(cursorPos + 2, cursorPos + 2)
+			}
+		}
+	}
+
+	/**
+   * Gère les événements paste pour filtrer les caractères non autorisés
+   */
+	const handlePaste = (event: ClipboardEvent): void => {
+		if (!event.clipboardData) return
+
+		const pastedText = event.clipboardData.getData('text')
+		if (!pastedText) return
+
+		// Filtrer pour ne garder que les caractères autorisés
+		const filteredText = pastedText
+			.split('')
+			.filter(char => allowedCharacters.test(char))
+			.join('')
+
+		// Si le texte collé ne contient pas de caractères autorisés, annuler l'opération
+		if (filteredText.length === 0) {
+			event.preventDefault()
+			return
+		}
+
+		// Si le texte a été modifié (des caractères non autorisés ont été supprimés)
+		if (filteredText !== pastedText) {
+			event.preventDefault()
+
+			const input = event.target as HTMLInputElement
+			if (!input) return
+
+			const start = input.selectionStart || 0
+			const end = input.selectionEnd || 0
+
+			// Construire la nouvelle valeur
+			const newValue = input.value.substring(0, start) + filteredText + input.value.substring(end)
+
+			// Mettre à jour la valeur (via l'événement input)
+			const inputEvent = new InputEvent('input', { bubbles: true, cancelable: true, data: newValue })
+			Object.defineProperty(inputEvent, 'target', { value: input, enumerable: true })
+			input.value = newValue
+			input.dispatchEvent(inputEvent)
+
+			// Positionner le curseur après le texte collé
+			setTimeout(() => {
+				const newCursorPos = start + filteredText.length
+				input.setSelectionRange(newCursorPos, newCursorPos)
+			}, 0)
+		}
+	}
+
+	return {
+		handleKeyDown,
+		handleArrowKeys,
+		handlePaste,
+	}
+}

package/src/components/DatePicker/composables/useManualDateValidation.ts

@@ -1,8 +1,11 @@
 import { type Ref } from 'vue'
 import { type ValidationResult } from '@/composables/validation/useValidation'
 import { DATE_PICKER_MESSAGES } from '../constants/messages'
-import { formatDate } from '@/utils/formatDate'
-import dayjs from 'dayjs'
+import {
+	adaptCustomRules,
+	validateEmptyOrIncompleteDate,
+	type CustomRule,
+} from '../utils/validationUtils'
 
 /**
  * Composable pour la validation manuelle des dates saisies
@@ -15,10 +18,8 @@ export const useManualDateValidation = (options: {
 	format: string
 	required?: boolean
 	disableErrorHandling?: boolean
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Règles personnalisées
-	customRules?: { type: string, options: any }[]
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Règles d'avertissement personnalisées
-	customWarningRules?: { type: string, options: any }[]
+	customRules?: CustomRule[]
+	customWarningRules?: CustomRule[]
 
 	// Références réactives
 	hasInteracted: Ref<boolean>
@@ -29,8 +30,7 @@ export const useManualDateValidation = (options: {
 	validateDateFormat: (dateStr: string) => { isValid: boolean, message: string }
 	isDateComplete: (value: string) => boolean
 	parseDate: (dateStr: string, format: string) => Date | null
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Règles personnalisées
-	validateField: (value: any, rules?: any[], warningRules?: any[]) => ValidationResult
+	validateField: (value: unknown, rules?: CustomRule[], warningRules?: CustomRule[]) => ValidationResult
 }) => {
 	const {
 		format,
@@ -57,23 +57,22 @@ export const useManualDateValidation = (options: {
 		// Réinitialiser la validation
 		clearValidation()
 
-		// Vérifier si le champ est requis et vide
-		if (!value && required && hasInteracted.value) {
-			if (!disableErrorHandling) {
-				errors.value.push(DATE_PICKER_MESSAGES.ERROR_REQUIRED)
-			}
-			return false
-		}
-
-		// Si le champ est vide et non requis, c'est valide
-		if (!value && !required) {
-			return true
+		// Vérifier les cas de champ vide ou incomplet
+		const emptyCheck = validateEmptyOrIncompleteDate(
+			value,
+			required,
+			isDateComplete,
+			hasInteracted.value,
+		)
+
+		// Gérer les erreurs pour champ vide requis
+		if (!emptyCheck.isValid && !disableErrorHandling && emptyCheck.errorMessage) {
+			errors.value.push(DATE_PICKER_MESSAGES.ERROR_REQUIRED)
 		}
 
-		// Vérifier si la saisie est complète avant de valider le format
-		if (!isDateComplete(value)) {
-			// La saisie n'est pas complète, ne pas afficher d'erreur
-			return true
+		// Si on ne doit pas continuer la validation (champ vide/incomplet)
+		if (!emptyCheck.shouldContinue) {
+			return emptyCheck.isValid
 		}
 
 		// Valider le format de la date
@@ -97,52 +96,12 @@ export const useManualDateValidation = (options: {
 
 		// Valider les règles personnalisées
 		if (!disableErrorHandling) {
-			// Pour maintenir la compatibilité avec les tests existants, nous devons appeler validateField
-			// avec tous les paramètres comme avant, mais nous devons aussi gérer correctement
-			// les règles personnalisées qui utilisent includes() sur des chaînes
-
-			// Pré-traitement des règles personnalisées pour éviter l'erreur "value.includes is not a function"
-			const safeCustomRules = customRules.map((rule) => {
-				if (rule.type === 'custom' && rule.options && rule.options.validate) {
-					// Créer une copie de la règle pour ne pas modifier l'original
-					const safeCopy = { ...rule }
-					const originalValidate = rule.options.validate
-
-					// Remplacer la fonction validate par une version sécurisée
-					safeCopy.options = { ...rule.options }
-					safeCopy.options.validate = (val: string | Date | null | undefined) => {
-						// Si la valeur est une Date mais que la fonction originale attend une chaîne
-						// (détecté par la présence de includes dans le code source)
-						if (val instanceof Date && originalValidate.toString().includes('.includes')) {
-							// Convertir la date en chaîne au format spécifié
-							return originalValidate(format ? formatDate(dayjs(val), format) : val.toISOString())
-						}
-						return originalValidate(val)
-					}
-					return safeCopy
-				}
-				return rule
-			})
-
-			// Faire de même pour les règles d'avertissement
-			const safeWarningRules = customWarningRules.map((rule) => {
-				if (rule.type === 'custom' && rule.options && rule.options.validate) {
-					const safeCopy = { ...rule }
-					const originalValidate = rule.options.validate
-
-					safeCopy.options = { ...rule.options }
-					safeCopy.options.validate = (val: string | Date | null | undefined) => {
-						if (val instanceof Date && originalValidate.toString().includes('.includes')) {
-							return originalValidate(format ? formatDate(dayjs(val), format) : val.toISOString())
-						}
-						return originalValidate(val)
-					}
-					return safeCopy
-				}
-				return rule
-			})
+			// Adapter les règles pour maintenir la compatibilité avec les tests existants
+			// en utilisant notre utilitaire pour éviter les erreurs de type
+			const safeCustomRules = adaptCustomRules(customRules, format)
+			const safeWarningRules = adaptCustomRules(customWarningRules, format)
 
-			// Appeler validateField comme avant pour maintenir la compatibilité avec les tests
+			// Appeler validateField pour évaluer les règles
 			const result = validateField(
 				date,
 				safeCustomRules,