@cnamts/synapse 1.0.26 → 1.0.27

package/src/components/Tables/common/filters/logics/tests/NumberFilterLogic.spec.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest'
+import filter from '../number'
+
+describe('Number filter logic', () => {
+	describe('itemValue non-number', () => {
+		it('retourne false si itemValue est une string', () => {
+			expect(filter('42', 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est null', () => {
+			expect(filter(null, 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est undefined', () => {
+			expect(filter(undefined, 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est un boolean', () => {
+			expect(filter(true, 1)).toBe(false)
+		})
+	})
+
+	describe('filterValue numérique (exact match)', () => {
+		it('retourne true pour une valeur égale', () => {
+			expect(filter(42, 42)).toBe(true)
+		})
+
+		it('retourne false pour une valeur différente', () => {
+			expect(filter(42, 43)).toBe(false)
+		})
+
+		it('retourne true pour 0 === 0', () => {
+			expect(filter(0, 0)).toBe(true)
+		})
+
+		it('retourne false pour 0 !== 1', () => {
+			expect(filter(0, 1)).toBe(false)
+		})
+
+		it('retourne true pour des négatifs égaux', () => {
+			expect(filter(-5, -5)).toBe(true)
+		})
+	})
+
+	describe('filterValue string sans opérateur', () => {
+		it('retourne true pour correspondance exacte via string', () => {
+			expect(filter(42, '42')).toBe(true)
+		})
+
+		it('retourne true pour string avec virgule décimale', () => {
+			expect(filter(3.14, '3,14')).toBe(true)
+		})
+
+		it('retourne true pour string avec point décimal', () => {
+			expect(filter(3.14, '3.14')).toBe(true)
+		})
+
+		it('retourne false pour une string non numérique', () => {
+			expect(filter(42, 'abc')).toBe(false)
+		})
+
+		it('retourne false si la valeur ne correspond pas', () => {
+			expect(filter(42, '43')).toBe(false)
+		})
+	})
+
+	describe('opérateur =', () => {
+		it('retourne true pour =42 avec itemValue 42', () => {
+			expect(filter(42, '=42')).toBe(true)
+		})
+
+		it('retourne false pour =42 avec itemValue 43', () => {
+			expect(filter(43, '=42')).toBe(false)
+		})
+
+		it('retourne false si la valeur après = est non numérique', () => {
+			expect(filter(42, '=abc')).toBe(false)
+		})
+	})
+
+	describe('opérateur <>', () => {
+		it('retourne true pour <>42 avec itemValue 43', () => {
+			expect(filter(43, '<>42')).toBe(true)
+		})
+
+		it('retourne false pour <>42 avec itemValue 42', () => {
+			expect(filter(42, '<>42')).toBe(false)
+		})
+	})
+
+	describe('opérateur <', () => {
+		it('retourne true si itemValue < filterValue', () => {
+			expect(filter(10, '<20')).toBe(true)
+		})
+
+		it('retourne false si itemValue === filterValue', () => {
+			expect(filter(20, '<20')).toBe(false)
+		})
+
+		it('retourne false si itemValue > filterValue', () => {
+			expect(filter(30, '<20')).toBe(false)
+		})
+	})
+
+	describe('opérateur <=', () => {
+		it('retourne true si itemValue < filterValue', () => {
+			expect(filter(10, '<=20')).toBe(true)
+		})
+
+		it('retourne true si itemValue === filterValue', () => {
+			expect(filter(20, '<=20')).toBe(true)
+		})
+
+		it('retourne false si itemValue > filterValue', () => {
+			expect(filter(30, '<=20')).toBe(false)
+		})
+	})
+
+	describe('opérateur >', () => {
+		it('retourne true si itemValue > filterValue', () => {
+			expect(filter(30, '>20')).toBe(true)
+		})
+
+		it('retourne false si itemValue === filterValue', () => {
+			expect(filter(20, '>20')).toBe(false)
+		})
+
+		it('retourne false si itemValue < filterValue', () => {
+			expect(filter(10, '>20')).toBe(false)
+		})
+	})
+
+	describe('opérateur >=', () => {
+		it('retourne true si itemValue > filterValue', () => {
+			expect(filter(30, '>=20')).toBe(true)
+		})
+
+		it('retourne true si itemValue === filterValue', () => {
+			expect(filter(20, '>=20')).toBe(true)
+		})
+
+		it('retourne false si itemValue < filterValue', () => {
+			expect(filter(10, '>=20')).toBe(false)
+		})
+	})
+
+	describe('virgule comme séparateur décimal dans opérateurs', () => {
+		it('retourne true pour >=3,5 avec itemValue 4', () => {
+			expect(filter(4, '>=3,5')).toBe(true)
+		})
+
+		it('retourne true pour <=3,5 avec itemValue 3', () => {
+			expect(filter(3, '<=3,5')).toBe(true)
+		})
+
+		it('retourne true pour =3,14 avec itemValue 3.14', () => {
+			expect(filter(3.14, '=3,14')).toBe(true)
+		})
+	})
+
+	describe('valeur NaN après opérateur', () => {
+		it('retourne false si la valeur après < est non numérique', () => {
+			expect(filter(42, '<abc')).toBe(false)
+		})
+
+		it('retourne false si la valeur après > est non numérique', () => {
+			expect(filter(42, '>abc')).toBe(false)
+		})
+	})
+
+	describe('fallback String.includes pour filterValue autre', () => {
+		it('retourne true si String(itemValue).includes(String(filterValue)) pour filterValue boolean', () => {
+			expect(filter(42, true as unknown as string)).toBe(false)
+		})
+	})
+})

package/src/components/Tables/common/filters/logics/tests/SelectFilterLogic.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest'
+import filter from '../select'
+
+describe('Select filter logic', () => {
+	describe('filterValue scalaire (valeur unique)', () => {
+		it('retourne true pour une correspondance exacte de string', () => {
+			expect(filter('foo', 'foo')).toBe(true)
+		})
+
+		it('retourne false pour une non-correspondance de string', () => {
+			expect(filter('foo', 'bar')).toBe(false)
+		})
+
+		it('retourne true pour une correspondance exacte de number', () => {
+			expect(filter(42, 42)).toBe(true)
+		})
+
+		it('retourne false pour une non-correspondance de number', () => {
+			expect(filter(42, 43)).toBe(false)
+		})
+
+		it('retourne true pour null === null', () => {
+			expect(filter(null, null)).toBe(true)
+		})
+
+		it('retourne false pour null !== "foo"', () => {
+			expect(filter(null, 'foo')).toBe(false)
+		})
+
+		it('retourne true pour boolean true === true', () => {
+			expect(filter(true, true)).toBe(true)
+		})
+
+		it('retourne false pour boolean true !== false', () => {
+			expect(filter(true, false)).toBe(false)
+		})
+	})
+
+	describe('filterValue objet (comparaison JSON)', () => {
+		it('retourne true pour deux objets identiques', () => {
+			expect(filter({ id: 1, label: 'A' }, { id: 1, label: 'A' })).toBe(true)
+		})
+
+		it('retourne false pour deux objets différents', () => {
+			expect(filter({ id: 1, label: 'A' }, { id: 2, label: 'B' })).toBe(false)
+		})
+
+		it('retourne false si itemValue est une string et filterValue un objet', () => {
+			expect(filter('foo', { id: 1 })).toBe(false)
+		})
+
+		it('retourne true pour deux objets imbriqués identiques', () => {
+			const obj = { a: { b: 1 } }
+			expect(filter({ a: { b: 1 } }, obj)).toBe(true)
+		})
+	})
+
+	describe('filterValue tableau — itemValue scalaire', () => {
+		it('retourne true si itemValue est dans le tableau', () => {
+			expect(filter('foo', ['foo', 'bar'])).toBe(true)
+		})
+
+		it('retourne false si itemValue n\'est pas dans le tableau', () => {
+			expect(filter('baz', ['foo', 'bar'])).toBe(false)
+		})
+
+		it('retourne true pour un number inclus dans le tableau', () => {
+			expect(filter(2, [1, 2, 3])).toBe(true)
+		})
+
+		it('retourne false pour un number non inclus dans le tableau', () => {
+			expect(filter(5, [1, 2, 3])).toBe(false)
+		})
+
+		it('retourne false pour un tableau filterValue vide', () => {
+			expect(filter('foo', [])).toBe(false)
+		})
+	})
+
+	describe('filterValue tableau — itemValue tableau', () => {
+		it('retourne true si au moins un élément commun (primitifs)', () => {
+			expect(filter(['Vue', 'React'], ['Vue', 'Angular'])).toBe(true)
+		})
+
+		it('retourne false si aucun élément commun (primitifs)', () => {
+			expect(filter(['Svelte', 'Angular'], ['Vue', 'React'])).toBe(false)
+		})
+
+		it('retourne true si au moins un objet commun (comparaison JSON)', () => {
+			expect(filter(
+				[{ id: 1 }, { id: 2 }],
+				[{ id: 2 }, { id: 3 }],
+			)).toBe(true)
+		})
+
+		it('retourne false si aucun objet commun (comparaison JSON)', () => {
+			expect(filter(
+				[{ id: 1 }],
+				[{ id: 2 }],
+			)).toBe(false)
+		})
+
+		it('retourne false si itemValue est tableau vide', () => {
+			expect(filter([], ['foo'])).toBe(false)
+		})
+
+		it('retourne false si filterValue est tableau vide', () => {
+			expect(filter(['foo'], [])).toBe(false)
+		})
+	})
+})

package/src/components/Tables/common/tableStyles.scss

@@ -56,28 +56,28 @@
 
 	// Override Vuetify's checkbox styles to use primary color
 	.v-table .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	.v-table .v-selection-control--dirty .v-selection-control__input::before {
-		background-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
-		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		background-color: rgb(var(--v-theme-primary)) !important;
+		border-color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Target the header checkbox specifically
 	.v-data-table-header__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Target the row checkboxes specifically
 	.v-data-table-row__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Add a global style for all checkboxes in the table
 	.v-checkbox .v-selection-control__input::before,
 	.v-checkbox-btn .v-selection-control__input::before {
-		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		border-color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	.v-data-table-rows-no-data {

package/src/components/Tables/common/types.ts

@@ -106,6 +106,7 @@ export type SyTableProps = {
 	pinnedColumnKey?: string
 	clickableRow?: boolean
 	pageInput?: boolean
+	hideDefaultFooter?: boolean
 }
 
 export type SyServerTableProps = {
@@ -134,4 +135,5 @@ export type SyServerTableProps = {
 	pinnedColumnKey?: string
 	clickableRow?: boolean
 	pageInput?: boolean
+	hideDefaultFooter?: boolean
 }

package/src/components/UploadWorkflow/tests/UploadWorkflow.spec.ts

@@ -48,10 +48,12 @@ describe('UploadWorkflow', () => {
 	})
 
 	it('handles undefined upload list without crashing', async () => {
+		const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 		const wrapper = mount(UploadWorkflow, {
 			/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
 			props: {} as any,
 		})
+		warnSpy.mockRestore()
 
 		expect(wrapper.html()).toMatchSnapshot()
 		expect(wrapper.findAll('.file-item')).toHaveLength(0)

package/src/components/index.ts

@@ -95,6 +95,7 @@ export { default as ChipList } from './ChipList/ChipList.vue'
 export * from './ChipList/types'
 export { default as CollapsibleList } from './CollapsibleList/CollapsibleList.vue'
 export { default as SyIcon } from './Customs/SyIcon/SyIcon.vue'
+export { default as SyIconButton } from './Customs/SyIconButton/SyIconButton.vue'
 export { default as DataList } from './DataList/DataList.vue'
 export { default as DataListGroup } from './DataListGroup/DataListGroup.vue'
 export { default as DataListItem } from './DataListItem/DataListItem.vue'

package/src/composables/date/tests/useDateFormatDayjs.spec.ts

@@ -96,5 +96,36 @@ describe('useDateFormatDayjs', () => {
 				process.env.TZ = previousTz
 			}
 		})
+
+		it('handles non-string non-Date input by converting to string', () => {
+			// Test avec un nombre qui sera converti en string
+			const result = parseDate(20230115 as unknown as string, 'YYYYMMDD')
+			expect(result).not.toBeNull()
+			expect(result?.getFullYear()).toBe(2023)
+		})
+
+		it('handles undefined input', () => {
+			expect(parseDate(undefined, 'DD/MM/YYYY')).toBeNull()
+		})
+	})
+
+	describe('useDateFormat composable', () => {
+		it('returns parseDate and formatDate functions', async () => {
+			const { useDateFormat } = await import('../useDateFormatDayjs')
+			const hook = useDateFormat()
+			expect(hook.parseDate).toBeDefined()
+			expect(hook.formatDate).toBeDefined()
+			expect(typeof hook.parseDate).toBe('function')
+			expect(typeof hook.formatDate).toBe('function')
+		})
+
+		it('uses returned functions correctly', async () => {
+			const { useDateFormat } = await import('../useDateFormatDayjs')
+			const { parseDate: hookParse, formatDate: hookFormat } = useDateFormat()
+
+			const date = hookParse('15/01/2023', 'DD/MM/YYYY')
+			expect(date).not.toBeNull()
+			expect(hookFormat(date, 'DD/MM/YYYY')).toBe('15/01/2023')
+		})
 	})
 })

package/src/composables/date/tests/useHolidayDay.spec.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest'
+import {
+	getJoursFeries,
+	isHolidayDay,
+	useHolidayDay,
+} from '../useHolidayDay'
+
+describe('useHolidayDay', () => {
+	const { calculPaquesGregorienne } = useHolidayDay()
+
+	describe('calculPaquesGregorienne', () => {
+		it('calculates Easter date for various years', () => {
+			// Pâques 2023: 9 avril
+			const paques2023 = calculPaquesGregorienne(2023)
+			expect(paques2023.jour).toBe(9)
+			expect(paques2023.mois).toBe(4)
+
+			// Pâques 2024: 31 mars
+			const paques2024 = calculPaquesGregorienne(2024)
+			expect(paques2024.jour).toBe(31)
+			expect(paques2024.mois).toBe(3)
+
+			// Pâques 2025: 20 avril
+			const paques2025 = calculPaquesGregorienne(2025)
+			expect(paques2025.jour).toBe(20)
+			expect(paques2025.mois).toBe(4)
+		})
+
+		it('handles years where sum <= 9 (Easter in March)', () => {
+			// Certaines années Pâques tombe en mars (sum <= 9)
+			const paques2016 = calculPaquesGregorienne(2016)
+			expect(paques2016.mois).toBe(3) // 27 mars 2016
+		})
+	})
+
+	describe('getJoursFeries', () => {
+		it('returns a Set of holidays for a given year', () => {
+			const holidays2023 = getJoursFeries(2023)
+			expect(holidays2023).toBeInstanceOf(Set)
+			expect(holidays2023.size).toBe(11) // 11 jours fériés fixes + variables
+		})
+
+		it('includes fixed holidays', () => {
+			const holidays2023 = getJoursFeries(2023)
+			expect(holidays2023.has('01/01/2023')).toBe(true) // Jour de l'an
+			expect(holidays2023.has('01/05/2023')).toBe(true) // Fête du travail
+			expect(holidays2023.has('08/05/2023')).toBe(true) // Victoire
+			expect(holidays2023.has('14/07/2023')).toBe(true) // Fête nationale
+			expect(holidays2023.has('15/08/2023')).toBe(true) // Assomption
+			expect(holidays2023.has('01/11/2023')).toBe(true) // Toussaint
+			expect(holidays2023.has('11/11/2023')).toBe(true) // Armistice
+			expect(holidays2023.has('25/12/2023')).toBe(true) // Noël
+		})
+
+		it('includes Easter-related holidays', () => {
+			const holidays2023 = getJoursFeries(2023)
+			// Pâques 2023: 9 avril
+			expect(holidays2023.has('10/04/2023')).toBe(true) // Lundi de Pâques
+			expect(holidays2023.has('18/05/2023')).toBe(true) // Ascension
+			expect(holidays2023.has('29/05/2023')).toBe(true) // Lundi de Pentecôte
+		})
+
+		it('accepts custom format', () => {
+			const holidays2023 = getJoursFeries(2023, 'YYYY-MM-DD')
+			expect(holidays2023.has('2023-01-01')).toBe(true)
+			expect(holidays2023.has('2023-12-25')).toBe(true)
+		})
+	})
+
+	describe('isHolidayDay', () => {
+		it('returns true for holidays', () => {
+			expect(isHolidayDay(new Date(2023, 0, 1))).toBe(true) // Jour de l'an
+			expect(isHolidayDay(new Date(2023, 4, 1))).toBe(true) // Fête du travail
+			expect(isHolidayDay(new Date(2023, 11, 25))).toBe(true) // Noël
+		})
+
+		it('returns false for non-holidays', () => {
+			expect(isHolidayDay(new Date(2023, 0, 2))).toBe(false) // 2 janvier
+			expect(isHolidayDay(new Date(2023, 5, 15))).toBe(false) // 15 juin
+		})
+
+		it('accepts string dates', () => {
+			expect(isHolidayDay('01/01/2023', 'DD/MM/YYYY')).toBe(true)
+			expect(isHolidayDay('02/01/2023', 'DD/MM/YYYY')).toBe(false)
+		})
+
+		it('accepts custom format', () => {
+			expect(isHolidayDay('2023-01-01', 'YYYY-MM-DD')).toBe(true)
+			expect(isHolidayDay('2023-12-25', 'YYYY-MM-DD')).toBe(true)
+		})
+
+		it('returns false for invalid dates', () => {
+			expect(isHolidayDay('invalid-date', 'DD/MM/YYYY')).toBe(false)
+			expect(isHolidayDay('', 'DD/MM/YYYY')).toBe(false)
+		})
+	})
+
+	describe('useHolidayDay composable', () => {
+		it('returns all functions', () => {
+			const hook = useHolidayDay()
+			expect(hook.getJoursFeries).toBeDefined()
+			expect(hook.isHolidayDay).toBeDefined()
+			expect(hook.calculPaquesGregorienne).toBeDefined()
+			expect(typeof hook.getJoursFeries).toBe('function')
+			expect(typeof hook.isHolidayDay).toBe('function')
+			expect(typeof hook.calculPaquesGregorienne).toBe('function')
+		})
+	})
+})