@cnamts/synapse 1.0.19 → 1.0.21

package/src/components/index.ts

@@ -50,7 +50,10 @@ export { default as Captcha } from './Captcha/Captcha.vue'
 export { default as SelectBtnField } from './Customs/Selects/SelectBtnField/SelectBtnField.vue'
 export { default as SyInputSelect } from './Customs/Selects/SyInputSelect/SyInputSelect.vue'
 export { default as SySelect } from './Customs/Selects/SySelect/SySelect.vue'
+export { default as SyAutocomplete } from './Customs/Selects/SyAutocomplete/SyAutocomplete.vue'
+// export { default as SyBtnSelect } from './Customs/Selects/SyBtnSelect/SyBtnSelect.vue'
 export { default as SyCheckbox } from './Customs/SyCheckbox/SyCheckbox.vue'
+export { default as SyCheckBoxGroup } from './Customs/SyCheckBoxGroup/SyCheckBoxGroup.vue'
 export { default as SyForm } from './Customs/SyForm/SyForm.vue'
 export { default as SyRadioGroup } from './Customs/SyRadioGroup/SyRadioGroup.vue'
 export { default as SyTextField } from './Customs/SyTextField/SyTextField.vue'
@@ -117,6 +120,8 @@ export { default as SyAlert } from './SyAlert/SyAlert.vue'
 export { default as ErrorPage } from './ErrorPage/ErrorPage.vue'
 export { default as MaintenancePage } from './MaintenancePage/MaintenancePage.vue'
 export { default as NotFoundPage } from './NotFoundPage/NotFoundPage.vue'
+export { default as StatusPage } from './StatusPage/StatusPage.vue'
+export { default as DeclarationAccessibilityPage } from './DeclarationAccessibilityPage/DeclarationAccessibilityPage.vue'
 
 // ===========================
 // Amelipro

package/src/components/types.ts

@@ -0,0 +1,10 @@
+import type { RouteLocationRaw } from 'vue-router'
+
+/**
+ * Type pour les props de navigation
+ * Permet de spécifier soit href (lien externe), soit to (route interne), soit ni l'un ni l'autre
+ */
+export type NavigationProps =
+	| { href: string, to?: never }
+	| { to: RouteLocationRaw, href?: never }
+	| { href?: never, to?: never }

package/src/composables/rules/tests/useFieldValidation.spec.ts

@@ -284,6 +284,18 @@ describe('useFieldValidation', () => {
 		}])[0]!
 		expect(ruleWithoutDate(new Date())).toEqual({ error: 'Configuration de la règle invalide' })
 		expect(rule('')).toEqual({}) // Empty string should be ignored
+
+		const ruleWithEmptyDate = generateRules([{
+			type: 'notBeforeDate',
+			options: { date: '', message: 'Date cannot be before reference date.' },
+		}])[0]!
+		expect(ruleWithEmptyDate(new Date())).toEqual({})
+
+		const ruleWithUndefinedDate = generateRules([{
+			type: 'notBeforeDate',
+			options: { date: undefined as unknown as string, message: 'Date cannot be before reference date.' },
+		}])[0]!
+		expect(ruleWithUndefinedDate(new Date())).toEqual({})
 	})
 
 	it('should throw when date reference is not a string in notBeforeDate rule', () => {
@@ -296,7 +308,7 @@ describe('useFieldValidation', () => {
 				},
 			}])[0]!
 			invalidRule(new Date())
-		}).toThrow('Date reference must be a string in DD/MM/YYYY format')
+		}).toThrow('La date de référence doit être une chaîne au format DD/MM/YYYY')
 	})
 
 	it('should validate notAfterDate rule', () => {
@@ -324,6 +336,18 @@ describe('useFieldValidation', () => {
 		}])[0]!
 		expect(ruleWithoutDate(new Date())).toEqual({ error: 'Configuration de la règle invalide' })
 		expect(rule('')).toEqual({}) // Empty string should be ignored
+
+		const ruleWithEmptyDate = generateRules([{
+			type: 'notAfterDate',
+			options: { date: '', message: 'Date cannot be after reference date.' },
+		}])[0]!
+		expect(ruleWithEmptyDate(new Date())).toEqual({})
+
+		const ruleWithUndefinedDate = generateRules([{
+			type: 'notAfterDate',
+			options: { date: undefined as unknown as string, message: 'Date cannot be after reference date.' },
+		}])[0]!
+		expect(ruleWithUndefinedDate(new Date())).toEqual({})
 	})
 
 	it('should throw when date reference is not a string in notAfterDate rule', () => {
@@ -336,7 +360,7 @@ describe('useFieldValidation', () => {
 				},
 			}])[0]!
 			invalidRule(new Date())
-		}).toThrow('Date reference must be a string in DD/MM/YYYY format')
+		}).toThrow('La date de référence doit être une chaîne au format DD/MM/YYYY')
 	})
 
 	it('should validate dateExact rule', () => {
@@ -364,6 +388,18 @@ describe('useFieldValidation', () => {
 		}])[0]!
 		expect(ruleWithoutDate(new Date())).toEqual({ error: 'Configuration de la règle invalide' })
 		expect(rule('')).toEqual({}) // Empty string should be ignored
+
+		const ruleWithEmptyDate = generateRules([{
+			type: 'dateExact',
+			options: { date: '', message: 'Date must be exactly the reference date.' },
+		}])[0]!
+		expect(ruleWithEmptyDate(new Date())).toEqual({})
+
+		const ruleWithUndefinedDate = generateRules([{
+			type: 'dateExact',
+			options: { date: undefined as unknown as string, message: 'Date must be exactly the reference date.' },
+		}])[0]!
+		expect(ruleWithUndefinedDate(new Date())).toEqual({})
 	})
 
 	it('should throw when date reference is not a string in dateExact rule', () => {
@@ -376,7 +412,7 @@ describe('useFieldValidation', () => {
 				},
 			}])[0]!
 			invalidRule(new Date())
-		}).toThrow('Date reference must be a string in DD/MM/YYYY format')
+		}).toThrow('La date de référence doit être une chaîne au format DD/MM/YYYY')
 	})
 
 	it('should validate custom rule', () => {

package/src/composables/rules/useFieldValidation.ts

@@ -233,14 +233,19 @@ export function useFieldValidation() {
 				}
 
 				case 'notBeforeDate': {
-					if (typeof options.date === 'undefined') {
+					const hasDateOption = Object.prototype.hasOwnProperty.call(options, 'date')
+					if (!hasDateOption) {
 						return { error: 'Configuration de la règle invalide' }
 					}
 					// Si la valeur est null ou vide, ne pas valider (champ vide autorisé)
 					if (value === null || value === undefined || value === '') {
 						return {}
 					}
-					if (options.date === null || (typeof options.date === 'string' && options.date.trim() === '')) {
+					if (
+						options.date === undefined
+						|| options.date === null
+						|| (typeof options.date === 'string' && options.date.trim() === '')
+					) {
 						return {}
 					}
 					const dateValue = parseDate(value)
@@ -250,7 +255,7 @@ export function useFieldValidation() {
 
 					// Check if options.date is a string and in DD/MM/YYYY format
 					if (typeof options.date !== 'string') {
-						throw new Error('Date reference must be a string in DD/MM/YYYY format')
+						throw new Error('La date de référence doit être une chaîne au format DD/MM/YYYY')
 					}
 
 					const referenceDate = parseDate(options.date)
@@ -269,14 +274,19 @@ export function useFieldValidation() {
 				}
 
 				case 'notAfterDate': {
-					if (typeof options.date === 'undefined') {
+					const hasDateOption = Object.prototype.hasOwnProperty.call(options, 'date')
+					if (!hasDateOption) {
 						return { error: 'Configuration de la règle invalide' }
 					}
 					// Si la valeur est null ou vide, ne pas valider (champ vide autorisé)
 					if (value === null || value === undefined || value === '') {
 						return {}
 					}
-					if (options.date === null || (typeof options.date === 'string' && options.date.trim() === '')) {
+					if (
+						options.date === undefined
+						|| options.date === null
+						|| (typeof options.date === 'string' && options.date.trim() === '')
+					) {
 						return {}
 					}
 					const dateValue = parseDate(value)
@@ -286,7 +296,7 @@ export function useFieldValidation() {
 
 					// Check if options.date is a string and in DD/MM/YYYY format
 					if (typeof options.date !== 'string') {
-						throw new Error('Date reference must be a string in DD/MM/YYYY format')
+						throw new Error('La date de référence doit être une chaîne au format DD/MM/YYYY')
 					}
 
 					const referenceDate = parseDate(options.date)
@@ -305,14 +315,19 @@ export function useFieldValidation() {
 				}
 
 				case 'dateExact': {
-					if (typeof options.date === 'undefined') {
+					const hasDateOption = Object.prototype.hasOwnProperty.call(options, 'date')
+					if (!hasDateOption) {
 						return { error: 'Configuration de la règle invalide' }
 					}
 					// Si la valeur est null ou vide, ne pas valider (champ vide autorisé)
 					if (value === null || value === undefined || value === '') {
 						return {}
 					}
-					if (options.date === null || (typeof options.date === 'string' && options.date.trim() === '')) {
+					if (
+						options.date === undefined
+						|| options.date === null
+						|| (typeof options.date === 'string' && options.date.trim() === '')
+					) {
 						return {}
 					}
 					const dateValue = parseDate(value)
@@ -321,7 +336,7 @@ export function useFieldValidation() {
 					}
 
 					if (typeof options.date !== 'string') {
-						throw new Error('Date reference must be a string in DD/MM/YYYY format')
+						throw new Error('La date de référence doit être une chaîne au format DD/MM/YYYY')
 					}
 
 					const referenceDate = parseDate(options.date)
@@ -366,6 +381,13 @@ export function useFieldValidation() {
 					if (result === true) {
 						return { success: options.successMessage || baseMessages.success }
 					}
+					// If result is undefined or falsy but not true, treat as invalid
+					if (result === false) {
+						return options.isWarning
+							? { warning: options.warningMessage || baseMessages.warning }
+							: { error: options.message || baseMessages.error }
+					}
+					// If result is a string, use it as error/warning message
 					return options.isWarning
 						? { warning: typeof result === 'string' ? result : options.warningMessage || baseMessages.warning }
 						: { error: typeof result === 'string' ? result : options.message || baseMessages.error }

package/src/composables/useFormFieldErrorHandling.ts

@@ -0,0 +1,141 @@
+import { computed, watch, type Ref } from 'vue'
+import { useValidation, type ValidationRule } from '@/composables/validation/useValidation'
+import { useValidatable } from '@/composables/validation/useValidatable'
+
+export interface UseFormFieldErrorHandlingProps {
+	errorMessages?: string[] | null
+	warningMessages?: string[] | null
+	successMessages?: string[] | null
+	hasError?: boolean
+	hasWarning?: boolean
+	hasSuccess?: boolean
+	customRules?: ValidationRule[]
+	customWarningRules?: ValidationRule[]
+	customSuccessRules?: ValidationRule[]
+	showSuccessMessages?: boolean
+	disableErrorHandling?: boolean
+	required?: boolean
+	label?: string
+	isValidateOnBlur?: boolean
+}
+
+export interface UseFormFieldErrorHandlingReturn {
+	validation: ReturnType<typeof useValidation>
+	hasError: Ref<boolean>
+	hasWarning: Ref<boolean>
+	hasSuccess: Ref<boolean>
+	errors: Ref<string[]>
+	warnings: Ref<string[]>
+	successes: Ref<string[]>
+	validateField: (value: unknown) => boolean
+	validateOnSubmit: () => boolean
+	checkErrorOnBlur: () => void
+}
+
+export const useFormFieldErrorHandling = (
+	props: UseFormFieldErrorHandlingProps,
+	modelValue: Ref<unknown>,
+	emitUpdate?: () => void,
+): UseFormFieldErrorHandlingReturn => {
+	const validation = useValidation({
+		customRules: props.customRules || [],
+		warningRules: props.customWarningRules || [],
+		successRules: props.customSuccessRules || [],
+		showSuccessMessages: props.showSuccessMessages ?? true,
+		fieldIdentifier: props.label,
+		disableErrorHandling: props.disableErrorHandling ?? false,
+	})
+
+	// Synchronisation des messages externes
+	watch(() => props.errorMessages, (newVal) => {
+		validation.errors.value = newVal || []
+	}, { immediate: true })
+
+	watch(() => props.warningMessages, (newVal) => {
+		validation.warnings.value = newVal || []
+	}, { immediate: true })
+
+	watch(() => props.successMessages, (newVal) => {
+		validation.successes.value = newVal || []
+	}, { immediate: true })
+
+	// Construction des règles de validation
+	const defaultRules = computed<ValidationRule[]>(() => props.required
+		? [{
+				type: 'required',
+				options: {
+					message: `Le champ ${props.label || 'ce champ'} est requis.`,
+					fieldIdentifier: props.label,
+				},
+			}]
+		: [],
+	)
+
+	const validateField = (value: unknown) => {
+		if (props.disableErrorHandling) {
+			return true
+		}
+
+		// Ne pas valider si la valeur est null/undefined et non requise
+		if (value == null && !props.required) {
+			validation.clearValidation()
+			return true
+		}
+
+		const result = validation.validateField(
+			value,
+			[...defaultRules.value, ...props.customRules!],
+			props.customWarningRules!,
+		)
+
+		return !result.hasError
+	}
+
+	const validateOnSubmit = () => {
+		return validateField(modelValue.value)
+	}
+
+	const checkErrorOnBlur = () => {
+		validateField(modelValue.value)
+		if (emitUpdate) {
+			emitUpdate()
+		}
+	}
+
+	watch(modelValue, (newValue) => {
+		if (!props.isValidateOnBlur) {
+			validateField(newValue)
+		}
+	})
+
+	watch([() => props.required, () => props.label], () => {
+		// Re-valider quand les règles changent
+		if (modelValue.value != null) {
+			validateField(modelValue.value)
+		}
+	}, { immediate: true })
+
+	const hasError = computed(() => validation.hasError.value || (props.hasError ?? false))
+	const hasWarning = computed(() => validation.hasWarning.value || (props.hasWarning ?? false))
+	const hasSuccess = computed(() => ((validation.hasSuccess.value && !hasError.value && !hasWarning.value) || (props.hasSuccess ?? false)) && (props.showSuccessMessages ?? true))
+
+	const errors = computed(() => [...validation.errors.value, ...(props.errorMessages || [])])
+	const warnings = computed(() => validation.warnings.value)
+	const successes = computed(() => validation.successes.value)
+
+	// Intégration avec le système de validation du formulaire
+	useValidatable(validateOnSubmit, validation.clearValidation)
+
+	return {
+		validation,
+		hasError,
+		hasWarning,
+		hasSuccess,
+		errors,
+		warnings,
+		successes,
+		validateField,
+		validateOnSubmit,
+		checkErrorOnBlur,
+	}
+}

package/src/modules.d.ts

@@ -2,3 +2,9 @@ declare module '*.svg' {
 	const content: string
 	export default content
 }
+
+declare module '*.mdx' {
+	import type { ComponentOptions } from 'vue'
+	const component: ComponentOptions
+	export default component
+}

package/src/stories/Accessibilite/KitDePreAudit/Preaudit.mdx

@@ -351,6 +351,9 @@ import '../../styles/shared.css';
 
   <h4>Outil éventuel</h4>
   <p>Utilisation du lecteur d'écran pour vérifier la navigation et l'accessibilité des formulaires, tel que l'indication du caractère obligatoire du champ, la liaison du champ aux aides à la saisie ainsi qu'aux messages d'erreurs, le comportement à la soumission du formulaire, etc.</p>
+
+   <h4>Ressources</h4>
+   <p><a href="https://bati-itao.github.io/learning/esdc-self-paced-web-accessibility-course/module6/forms-concepts-fr.html">Concepts des formulaires</a></p>
 </div>
 
 <div className="verification-card">
@@ -375,6 +378,8 @@ import '../../styles/shared.css';
       <li>Les en-têtes de colonnes des tableaux utilisent des balises `th` avec l'attribut `scope="col"`.</li>
     </ul>
   </div>
+  <h4>Ressources</h4>
+   <p><a href="https://bati-itao.github.io/learning/esdc-self-paced-web-accessibility-course/module4/tables-concepts-fr.html">Concepts des tableaux</a></p>
 </div>
 
 <div className="verification-card">
@@ -432,6 +437,8 @@ import '../../styles/shared.css';
   </ol>
   <h4>Outil éventuel</h4>
   <p>Aucun</p>
+  <h4>Ressources</h4>
+  <p><a href="https://bati-itao.github.io/learning/esdc-self-paced-web-accessibility-course/module9/introduction-fr.html">Concepts des contenus multimédia</a></p>
 </div>
 
 <div className="info-section">

package/src/utils/theme/index.ts

@@ -0,0 +1,19 @@
+import { computed } from 'vue'
+import { useTheme } from 'vuetify'
+import type { ComputedRef } from 'vue'
+
+export function useThemeLocales<
+	T extends Record<string, unknown> & { default: unknown },
+>(locales: T): {
+	themeLocales: ComputedRef<T[keyof T]>
+} {
+	const vuetifyTheme = useTheme()
+
+	const themeLocales = computed((): T[keyof T] => {
+		return (locales[vuetifyTheme.name.value as keyof T] ?? locales.default) as T[keyof T]
+	})
+
+	return {
+		themeLocales,
+	}
+}

package/src/utils/theme/tests/useThemeLocales.spec.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useThemeLocales } from '../index'
+import { useTheme } from 'vuetify'
+import { nextTick, ref } from 'vue'
+import type { Mock } from 'vitest'
+
+// Mock Vuetify
+vi.mock('vuetify', () => ({
+	useTheme: vi.fn(),
+}))
+
+describe('useThemeLocales', () => {
+	let mockTheme: { name: ReturnType<typeof ref<string>> }
+
+	beforeEach(() => {
+		// Reset mock before each test
+		vi.clearAllMocks()
+
+		// Setup default mock theme with reactive ref
+		mockTheme = {
+			name: ref('default'),
+		}
+		;(useTheme as Mock).mockReturnValue(mockTheme)
+	})
+
+	it('should return themeLocales computed property', () => {
+		const locales = {
+			default: { title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' },
+		}
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales).toBeDefined()
+		expect(themeLocales.value).toEqual({ title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' })
+	})
+
+	it('should return default locale when theme name is not found', () => {
+		const locales = {
+			default: { title: 'Default Title', message: 'Default Message', pageTitle: 'Default', code: '500' },
+			cnam: { title: 'CNAM Title', message: 'CNAM Message', pageTitle: 'CNAM', code: '500' },
+		}
+
+		mockTheme.name.value = 'unknown'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			title: 'Default Title',
+			message: 'Default Message',
+			pageTitle: 'Default',
+			code: '500',
+		})
+	})
+
+	it('should return locale for cnam theme', () => {
+		const locales = {
+			default: { title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' },
+			cnam: { title: 'CNAM Title', message: 'CNAM Message', pageTitle: 'CNAM', code: '500' },
+		}
+
+		mockTheme.name.value = 'cnam'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			title: 'CNAM Title',
+			message: 'CNAM Message',
+			pageTitle: 'CNAM',
+			code: '500',
+		})
+	})
+
+	it('should return locale for ap theme', () => {
+		const locales = {
+			default: { title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' },
+			ap: { title: 'AP Title', message: 'AP Message', pageTitle: 'AP', code: '500' },
+		}
+
+		mockTheme.name.value = 'ap'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			title: 'AP Title',
+			message: 'AP Message',
+			pageTitle: 'AP',
+			code: '500',
+		})
+	})
+
+	it('should return locale for ap2026 theme', () => {
+		const locales = {
+			default: { title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' },
+			ap2026: { title: 'AP 2026 Title', message: 'AP 2026 Message', pageTitle: 'AP2026', code: '500' },
+		}
+
+		mockTheme.name.value = 'ap2026'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			title: 'AP 2026 Title',
+			message: 'AP 2026 Message',
+			pageTitle: 'AP2026',
+			code: '500',
+		})
+	})
+
+	it('should update themeLocales when theme changes', async () => {
+		const locales = {
+			default: { title: 'Default Title', pageTitle: 'Default', message: 'msg', code: '500' },
+			cnam: { title: 'CNAM Title', pageTitle: 'CNAM', message: 'msg', code: '500' },
+			ap: { title: 'AP Title', pageTitle: 'AP', message: 'msg', code: '500' },
+		}
+
+		// Initial theme
+		mockTheme.name.value = 'cnam'
+		const { themeLocales } = useThemeLocales(locales)
+		expect(themeLocales.value.title).toBe('CNAM Title')
+
+		// Change theme
+		mockTheme.name.value = 'ap'
+		await nextTick()
+		expect(themeLocales.value.title).toBe('AP Title')
+
+		// Change to default
+		mockTheme.name.value = 'default'
+		await nextTick()
+		expect(themeLocales.value.title).toBe('Default Title')
+	})
+
+	it('should handle complex locale objects', () => {
+		const locales = {
+			default: {
+				pageTitle: 'Error',
+				message: 'An error occurred',
+				code: '500',
+				src: undefined,
+			},
+			cnam: {
+				pageTitle: 'Error CNAM',
+				message: 'An error occurred at CNAM',
+				code: '500',
+				src: undefined,
+			},
+			ap: {
+				pageTitle: 'Error AP',
+				message: 'An error occurred at AP',
+				code: '500',
+				src: 'image-ap.svg',
+			},
+		}
+
+		mockTheme.name.value = 'ap'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			pageTitle: 'Error AP',
+			message: 'An error occurred at AP',
+			code: '500',
+			src: 'image-ap.svg',
+		})
+	})
+
+	it('should maintain reactivity across multiple instances', async () => {
+		const locales = {
+			default: { title: 'Default', pageTitle: 'Default', message: 'msg', code: '500' },
+			cnam: { title: 'CNAM', pageTitle: 'CNAM', message: 'msg', code: '500' },
+		}
+
+		const { themeLocales: locales1 } = useThemeLocales(locales)
+		const { themeLocales: locales2 } = useThemeLocales(locales)
+
+		mockTheme.name.value = 'cnam'
+		await nextTick()
+
+		expect(locales1.value.title).toBe('CNAM')
+		expect(locales2.value.title).toBe('CNAM')
+	})
+
+	it('should handle locale with null or undefined values', () => {
+		const locales = {
+			default: { title: 'Default', icon: null, description: undefined, pageTitle: 'Default', message: 'msg', code: '500' },
+			cnam: { title: 'CNAM', icon: null, description: undefined, pageTitle: 'CNAM', message: 'msg', code: '500' },
+		}
+
+		mockTheme.name.value = 'cnam'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value.title).toBe('CNAM')
+		expect(themeLocales.value.icon).toBeNull()
+	})
+
+	it('should work with generic type inference', () => {
+		const locales = {
+			default: { title: 'Default', message: 'Default message', pageTitle: 'Default', code: '500' },
+			cnam: {
+				title: 'CNAM',
+				message: 'CNAM message',
+				code: '500',
+				pageTitle: 'CNAM',
+			},
+		}
+
+		mockTheme.name.value = 'cnam'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value.title).toBe('CNAM')
+		expect(themeLocales.value.message).toBe('CNAM message')
+	})
+
+	it('should prefer theme locale over default when available', () => {
+		const locales = {
+			default: { title: 'Default Title', message: 'Default Message', pageTitle: 'Default', code: '500' },
+			custom: { title: 'Custom Title', message: 'Custom Message', pageTitle: 'Custom', code: '500' },
+		}
+
+		mockTheme.name.value = 'custom'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value.title).toBe('Custom Title')
+		expect(themeLocales.value.message).toBe('Custom Message')
+	})
+
+	it('should fallback to default when accessing non-existent theme', () => {
+		const locales = {
+			default: { title: 'Default', message: 'Default message', pageTitle: 'Default', code: '500' },
+		}
+
+		mockTheme.name.value = 'nonexistent'
+
+		const { themeLocales } = useThemeLocales(locales)
+
+		expect(themeLocales.value).toEqual({
+			title: 'Default',
+			message: 'Default message',
+			pageTitle: 'Default',
+			code: '500',
+		})
+	})
+})

package/dist/components/MaintenancePage/index.d.ts

@@ -1,2 +0,0 @@
-import { default as MaintenancePage } from './MaintenancePage';
-export default MaintenancePage;

package/src/components/BackBtn/Accessibilite.mdx

@@ -1,14 +0,0 @@
-import { Meta, Story } from '@storybook/addon-docs';
-import * as AccessStories from './Accessibilite.stories.ts';
-import '../../stories/styles/shared.css';
-
-<Meta of={AccessStories} />
-
-<div className="header">
-  <h1>Accessibilité</h1>
-  <p>Informations sur l'accessibilité du composant</p>
-</div>
-
-<Story of={AccessStories.Legende} />
-<br />
-