@cnamts/synapse 1.0.1 → 1.0.2

package/src/components/Tables/common/filters/logics/date.ts

@@ -0,0 +1,12 @@
+import { parseDate } from '../../tableFilterUtils'
+
+export default function filter(itemValue: unknown, filterValue: unknown): boolean {
+	const itemDate = parseDate(itemValue)
+	const targetDate = parseDate(filterValue)
+	if (!itemDate || !targetDate) return false
+	return (
+		itemDate.getDate() === targetDate.getDate()
+		&& itemDate.getMonth() === targetDate.getMonth()
+		&& itemDate.getFullYear() === targetDate.getFullYear()
+	)
+}

package/src/components/Tables/common/filters/logics/number.ts

@@ -0,0 +1,48 @@
+export default function filter(itemValue: unknown, filterValue: unknown): boolean {
+	if (typeof itemValue === 'number') {
+		// Handle string filter values that may contain operators
+		if (typeof filterValue === 'string') {
+			// Check for operators at the beginning of the string
+			const operatorMatch = /^([=<>]{1,2})(.+)$/.exec(filterValue)
+			if (operatorMatch) {
+				const operator = operatorMatch[1]
+				const valueStr = operatorMatch[2].trim()
+				const numValue = parseFloat(valueStr.replace(',', '.'))
+
+				if (isNaN(numValue)) return false
+
+				switch (operator) {
+					case '=':
+						return itemValue === numValue
+					case '<>':
+						return itemValue !== numValue
+					case '<':
+						return itemValue < numValue
+					case '<=':
+						return itemValue <= numValue
+					case '>':
+						return itemValue > numValue
+					case '>=':
+						return itemValue >= numValue
+					default:
+						return false
+				}
+			}
+
+			// No operator, try to parse the value and do exact match
+			const numValue = parseFloat(filterValue.replace(',', '.'))
+			if (!isNaN(numValue)) {
+				return itemValue === numValue
+			}
+			return false
+		}
+
+		// Handle numeric filter values (exact match)
+		if (typeof filterValue === 'number') {
+			return itemValue === filterValue
+		}
+
+		return String(itemValue).includes(String(filterValue))
+	}
+	return false
+}

package/src/components/Tables/common/filters/logics/period.ts

@@ -0,0 +1,25 @@
+import { parseDate } from '../../tableFilterUtils'
+
+export default function filter(itemValue: unknown, filterValue: unknown): boolean {
+	const itemDate = parseDate(itemValue)
+	if (
+		typeof filterValue !== 'object'
+		|| filterValue === null
+		|| 'from' in filterValue === false
+		|| 'to' in filterValue === false
+	) throw new Error('Invalid filter value for period type')
+
+	const min = parseDate(filterValue.from)
+	const max = parseDate(filterValue.to)
+
+	if (itemDate) {
+		if (min && itemDate < min) {
+			return false
+		}
+		if (max && itemDate > max) {
+			return false
+		}
+	}
+
+	return true
+}

package/src/components/Tables/common/filters/logics/select.ts

@@ -0,0 +1,27 @@
+export default function filter(itemValue: unknown, filterValue: unknown): boolean {
+	// Handle multiple selection (filterValue is array)
+	if (Array.isArray(filterValue)) {
+		// If itemValue is also an array (e.g., item.skills = ['JavaScript', 'Vue'])
+		if (Array.isArray(itemValue)) {
+			// Check if any value in filterValue matches any value in itemValue
+			return filterValue.some(fv =>
+				itemValue.some(iv =>
+					// Handle both primitive values and objects
+					typeof fv === 'object' && fv !== null && typeof iv === 'object' && iv !== null
+						? JSON.stringify(fv) === JSON.stringify(iv)
+						: fv === iv,
+				),
+			)
+		}
+		else {
+			// If itemValue is a single value, check if it's included in filterValue
+			return filterValue.includes(itemValue as unknown as typeof filterValue[0])
+		}
+	}
+	// Handle object comparison
+	if (typeof filterValue === 'object' && filterValue !== null) {
+		return JSON.stringify(filterValue) === JSON.stringify(itemValue)
+	}
+	// Handle single value comparison
+	return itemValue === filterValue
+}

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

@@ -0,0 +1,177 @@
+import { it, expect, describe } from 'vitest'
+import filter from '../text'
+
+describe('Text filter logic', () => {
+	it('should return true for empty string and empty filter', () => {
+		expect(filter('', '')).toBe(true)
+	})
+
+	it('should return true for null item value and empty filter', () => {
+		expect(filter(null, '')).toBe(true)
+	})
+
+	it('should return false for null item value and non-empty filter', () => {
+		expect(filter(null, 'test')).toBe(false)
+	})
+
+	it('should return true for exact match', () => {
+		expect(filter('test', 'test')).toBe(true)
+	})
+
+	it('should return false for non-matching strings', () => {
+		expect(filter('test', 'example')).toBe(false)
+	})
+
+	it('should perform case-insensitive search by default', () => {
+		expect(filter('Test', 'test')).toBe(true)
+	})
+
+	it('should handle special characters in filter', () => {
+		expect(filter('hello world!', 'world')).toBe(true)
+		expect(filter('hello world!', 'WORLD')).toBe(true)
+	})
+
+	it('should handle empty filter string', () => {
+		expect(filter('any text', '')).toBe(true)
+	})
+
+	it('should not take accents into account', () => {
+		expect(filter('café', 'cafe')).toBe(true)
+		expect(filter('café', 'Café')).toBe(true)
+		expect(filter('café', 'CAFE')).toBe(true)
+		expect(filter('éèêëùûüîïñ', 'eeeuuuiin')).toBe(true)
+		expect(filter('éèêëùûüîïñ', 'ÉÈÊËÙÛÜÎÏÑ')).toBe(true)
+	})
+
+	it('return true for a sequence found in the middle of a string or a word', () => {
+		expect(filter('hello world', 'lo wo')).toBe(true)
+		expect(filter('hello world', 'lo W')).toBe(true)
+		expect(filter('hello world', 'loW')).toBe(false)
+	})
+
+	it('handles guillemets to case-sensitive search', () => {
+		expect(filter('Hello World', '"Hello"')).toBe(true)
+		expect(filter('Hello World', '"hello"')).toBe(false)
+		expect(filter('Hello World', '"WORLD"')).toBe(false)
+		expect(filter('Hello World', '"world"')).toBe(false)
+	})
+
+	it('handles guillemets to accents sensitive search', () => {
+		expect(filter('café', '"cafe"')).toBe(false)
+		expect(filter('éèêëùûüîïñ', '"éèêëùûüîïñ"')).toBe(true)
+		expect(filter('éèêëùûüîïñ', '"eeeuuuiin"')).toBe(false)
+		expect(filter('éèêëùûüîïñ', '"ÉÈÊËÙÛÜÎÏÑ"')).toBe(false)
+	})
+
+	it('perform a scrict comparaison when the search string begin by a =', () => {
+		expect(filter('lorem ipsum', '=lorem ipsum')).toBe(true)
+		expect(filter('lorem ipsum', '=lorem Ipsum')).toBe(false)
+		expect(filter('lorem ipsum', '=lorem ipsum ')).toBe(false)
+		expect(filter('lorem ipsum', '=ipsum')).toBe(false)
+		expect(filter('lorem ipsum', '=lorem')).toBe(false)
+	})
+
+	it('permorm a non equal comparaison when the search string begin by <>', () => {
+		expect(filter('lorem ipsum', '<>lorem ipsum')).toBe(false)
+		expect(filter('lorem ipsum', '<>lorem Ipsum')).toBe(true)
+	})
+
+	it('accepts the wildcard ? in the search string', () => {
+		expect(filter('lorem ipsum', 'lorem ?psum')).toBe(true)
+		expect(filter('lorem ipsum', 'lorem ?psu?')).toBe(true)
+		expect(filter('lorem ipsum', '???????????')).toBe(true)
+		expect(filter('lorem ipsum', 'lorem ?psu?m')).toBe(false)
+	})
+
+	it('accepts the wildcard * in the search string', () => {
+		expect(filter('lorem ipsum', 'lorem *um')).toBe(true)
+		expect(filter('lorem ipsum', 'lorem*psu*')).toBe(true)
+		expect(filter('lorem ipsum', '*ipsum')).toBe(true)
+		expect(filter('lorem ipsum', 'lorem*')).toBe(true)
+	})
+
+	it('accepts the mixed use of the secials caracters in the search string', () => {
+		expect(filter('lorem ipsum', '=l?rem ip*')).toBe(true)
+		expect(filter('lorem ipsum', '=l?rEm ip*')).toBe(false)
+		expect(filter('lorem ipsum', '<>l?rem ip*')).toBe(false)
+		expect(filter('lorem ipsum', '<>l?rem ipsul')).toBe(true)
+		expect(filter('lorem ipsum', '"lorem*psum"')).toBe(true)
+		expect(filter('lorem ipsum', '"lorém*psum"')).toBe(false)
+	})
+
+	it('returns true when a next letter is found and the superior than operator is used', () => {
+		expect(filter('b', '>a')).toBe(true)
+		expect(filter('b', '>b')).toBe(false)
+		expect(filter('b', '>c')).toBe(false)
+		expect(filter('café', '>b')).toBe(true)
+		expect(filter('café', '>c')).toBe(true)
+		expect(filter('café', '>cd')).toBe(false)
+		expect(filter('café', '>d')).toBe(false)
+	})
+
+	it('returns true when a next letter is found and the inferior than operator is used', () => {
+		expect(filter('b', '<c')).toBe(true)
+		expect(filter('b', '<b')).toBe(false)
+		expect(filter('b', '<a')).toBe(false)
+		expect(filter('café', '<d')).toBe(true)
+		expect(filter('café', '<c')).toBe(false)
+		expect(filter('café', '<ca')).toBe(false)
+		expect(filter('café', '<e')).toBe(true)
+	})
+
+	it('returns true when a next letter is found and the superior or equal than operator is used', () => {
+		expect(filter('b', '>=a')).toBe(true)
+		expect(filter('b', '>=b')).toBe(true)
+		expect(filter('b', '>=c')).toBe(false)
+		expect(filter('café', '>=b')).toBe(true)
+		expect(filter('café', '>=c')).toBe(true)
+		expect(filter('café', '>=cd')).toBe(false)
+		expect(filter('café', '>=d')).toBe(false)
+	})
+
+	it('returns true when a next letter is found and the inferior or equal than operator is used', () => {
+		expect(filter('b', '<=c')).toBe(true)
+		expect(filter('b', '<=b')).toBe(true)
+		expect(filter('b', '<=a')).toBe(false)
+		expect(filter('café', '<=d')).toBe(true)
+		expect(filter('café', '<=c')).toBe(false)
+		expect(filter('café', '<=ca')).toBe(false)
+		expect(filter('café', '<=e')).toBe(true)
+	})
+
+	describe('specs specifics tests', () => {
+		it('matches all words starting with "p" regardless of case', () => {
+			expect(filter('pomme', 'p*')).toBe(true)
+			expect(filter('Pomme', 'p*')).toBe(true)
+			expect(filter('banane', 'p*')).toBe(false)
+		})
+
+		it('matches all words of exactly 4 letters', () => {
+			expect(filter('test', '=????')).toBe(true)
+			expect(filter('test', '=????')).toBe(true)
+			expect(filter('tests', '=????')).toBe(false)
+			expect(filter('tes', '=????')).toBe(false)
+		})
+
+		it('matches all empty values', () => {
+			expect(filter('', '<>?*')).toBe(true)
+			expect(filter(null, '<>?*')).toBe(true)
+			expect(filter('test', '<>?*')).toBe(false)
+			expect(filter(' ', '<>?*')).toBe(false)
+		})
+
+		it('matches all words containing a capital "W"', () => {
+			expect(filter('Hello World', '"W"')).toBe(true)
+			expect(filter('hello world', '"W"')).toBe(false)
+			expect(filter('World', '"W"')).toBe(true)
+			expect(filter('world', '"W"')).toBe(false)
+		})
+
+		it('matches all words alphabetically after "zu"', () => {
+			expect(filter('zucchini', '>zu')).toBe(true)
+			expect(filter('zu', '>zu')).toBe(false)
+			expect(filter('zebra', '>zu')).toBe(false)
+			expect(filter('apple', '>zu')).toBe(false)
+		})
+	})
+})

package/src/components/Tables/common/filters/logics/text.ts

@@ -0,0 +1,62 @@
+export default function filter(itemValue: unknown, filterValue: unknown): boolean {
+	const str = String(itemValue ?? '')
+	const search = String(filterValue ?? '')
+
+	if (search.startsWith('"') && search.endsWith('"')) {
+		const regex = generateRegex(search.slice(1, -1), true)
+		return regex.test(str)
+	}
+
+	else if (search.startsWith('=')) {
+		const regex = generateRegex(search.slice(1), true, true)
+		return regex.test(str)
+	}
+
+	else if (search.startsWith('<>')) {
+		const regex = generateRegex(search.slice(2), true, true)
+		return !regex.test(str)
+	}
+
+	else if (search.startsWith('<=')) {
+		const cleanedSearch = search.slice(2).trim()
+		return str.localeCompare(cleanedSearch) <= 0
+	}
+
+	else if (search.startsWith('>=')) {
+		const cleanedSearch = search.slice(2).trim()
+		return str.localeCompare(cleanedSearch) >= 0
+	}
+
+	else if (search.startsWith('>')) {
+		const cleanedSearch = search.slice(1).trim()
+		return str.localeCompare(cleanedSearch) > 0
+	}
+
+	else if (search.startsWith('<')) {
+		const cleanedSearch = search.slice(1).trim()
+		return str.localeCompare(cleanedSearch) < 0
+	}
+
+	else {
+		const regex = generateRegex(removeAccents(search))
+		return regex.test(removeAccents(str))
+	}
+}
+
+function generateRegex(search: string, caseSensitive = false, strict = false): RegExp {
+	const escapedSearch = search.replace(/[-[\]{}()+.,\\^$|#\s]/g, '\\$&')
+	const regexSequenceWithWildcards = escapedSearch.replace(/\?/g, '.')
+	let regex = regexSequenceWithWildcards.replace(/\*/g, '.*')
+	if (strict) {
+		regex = '^' + regex + '$'
+	}
+	else if (regex !== escapedSearch) {
+		regex = '^' + regex
+	}
+
+	return new RegExp(regex, caseSensitive ? 'g' : 'gi')
+}
+
+function removeAccents(str: string): string {
+	return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+}

package/src/components/Tables/common/filters/tests/TextFilter.spec.ts

@@ -117,7 +117,7 @@ describe('TextFilter.vue', () => {
 
 		// Émettre une valeur pour déclencher la mise à jour du filtre
 		const syTextField = newWrapper.findComponent(SyTextField)
-		await syTextField.vm.$emit('update:modelValue', 'test value')
+		syTextField.vm.$emit('update:modelValue', 'test value')
 
 		// Vérifier que l'événement a été émis avec une clé générée basée sur le titre
 		expect(newWrapper.emitted('update:filters')).toBeTruthy()
@@ -193,15 +193,15 @@ describe('TextFilter.vue', () => {
 		it('supports wildcard * for any string of characters', () => {
 			const filters = [{ key: 'text', value: 'a*', type: 'text' as FilterType }]
 			const result = filterItems(testItems, filters)
-			expect(result).toHaveLength(2)
-			expect(result.map(item => item.id)).toEqual([1, 2])
+			expect(result).toHaveLength(1)
+			expect(result.map(item => item.id)).toEqual([1])
 		})
 
 		it('supports wildcard ? for any single character', () => {
 			const filters = [{ key: 'text', value: '????', type: 'text' as FilterType }]
 			const result = filterItems(testItems, filters)
-			expect(result).toHaveLength(3)
-			expect(result.map(item => item.id)).toEqual([1, 4, 6])
+			expect(result).toHaveLength(6) // the word should have at least 4 characterss
+			expect(result.map(item => item.id)).toEqual([1, 2, 3, 4, 5, 7])
 		})
 
 		it('supports case-sensitive search with double quotes', () => {
@@ -223,27 +223,27 @@ describe('TextFilter.vue', () => {
 			expect(result[0].id).toBe(5)
 		})
 
-		it('supports exact length search with =????', () => {
+		it('supports exact length search equal and question marks', () => {
 			const filters = [{ key: 'text', value: '=????', type: 'text' as FilterType }]
 			const result = filterItems(testItems, filters)
-			expect(result).toHaveLength(3)
-			expect(result.map(item => item.id)).toEqual([1, 4, 6])
+			expect(result).toHaveLength(1)
+			expect(result.map(item => item.id)).toEqual([4])
 
 			// Test with different length
 			const filters2 = [{ key: 'text', value: '=?????', type: 'text' as FilterType }]
 			const result2 = filterItems(testItems, filters2)
 			expect(result2).toHaveLength(2)
-			expect(result2.map(item => item.id)).toEqual([2, 5])
+			expect(result2.map(item => item.id)).toEqual([1, 7])
 		})
 
-		it('supports empty or null value search with <>?*', () => {
+		it('supports empty or null value search with not equal operator', () => {
 			const filters = [{ key: 'text', value: '<>?*', type: 'text' as FilterType }]
 			const result = filterItems(testItems, filters)
 			expect(result).toHaveLength(2)
 			expect(result.map(item => item.id)).toEqual([8, 9])
 		})
 
-		it('supports alphabetical comparison with >', () => {
+		it('supports alphabetical comparison with superior operator', () => {
 			const filters = [{ key: 'text', value: '>f', type: 'text' as FilterType }]
 			const result = filterItems(testItems, filters)
 			expect(result).toHaveLength(2)

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

@@ -1,7 +1,31 @@
 export const locales = {
+	// Table locales
 	resetFilters: 'Réinitialiser les filtres',
 	noData: 'Aucune donnée disponible',
 	columnOrder: (columnTitle: string) => `Ordonner par ${columnTitle}`,
 	ResizableColumn: 'Redimensionner la colonne',
 	resizeColumn: (columnTitle: string) => `Redimensionner la colonne ${columnTitle}`,
+	selectAllRows: 'Sélectionner toutes les lignes',
+	selectRow: 'Sélectionner la ligne',
+
+	// Pagination locales
+	pagination: {
+		itemsPerPageText: 'Lignes par page:',
+		previous: 'Précédent',
+		next: 'Suivant',
+		all: 'Tous',
+		showingItems: (start: number, end: number, total: number) => `${start}-${end} sur ${total} éléments`,
+		pageText: (page: number) => `${page}`,
+		pageAriaLabel: (page: number) => `Page ${page}`,
+		currentPageAriaLabel: (page: number) => `Page courante, Page ${page}`,
+		paginationNavAriaLabel: 'Navigation de pagination',
+	},
+	reorganizeColumns: 'Gestion des colonnes',
+	close: 'Fermer',
+	apply: 'Appliquer',
+	reorganizeColumnsTitle: 'Gestion des colonnes',
+	hideColumn: (columnTitle: string) => `Masquer la colonne ${columnTitle}`,
+	showColumn: (columnTitle: string) => `Afficher la colonne ${columnTitle}`,
+	moveColumnLeft: (columnTitle: string) => `Déplacer la colonne ${columnTitle} vers la gauche`,
+	moveColumnRight: (columnTitle: string) => `Déplacer la colonne ${columnTitle} vers la droite`,
 }