refactor: switch from filteredTasks to regularTasks in filter components

- Updated `JiraFilters`, `PriorityFilters`, `TagFilters`, and `TfsFilters` to use `regularTasks` instead of `filteredTasks` for task counts and available options.
- This change ensures that all tasks are considered, improving the accuracy of project and type availability across filters.
- Adjusted related logic and comments for clarity and consistency.

src/components/kanban/filters/JiraFilters.tsx

@@ -11,53 +11,53 @@ interface JiraFiltersProps {
 }
 
 export function JiraFilters({ filters, onFiltersChange }: JiraFiltersProps) {
-  const { regularTasks, filteredTasks } = useTasksContext();
+  const { regularTasks } = useTasksContext();
 
   // Vérifier s'il y a des tâches Jira dans le système (même masquées)
   const hasJiraTasks = regularTasks.some(task => task.source === 'jira');
 
-  // Récupérer les projets et types Jira disponibles dans les tâches filtrées
+  // Récupérer les projets et types Jira disponibles dans toutes les tâches
   const availableJiraProjects = useMemo(() => {
     const projects = new Set<string>();
-    filteredTasks.forEach(task => {
+    regularTasks.forEach(task => {
       if (task.source === 'jira' && task.jiraProject) {
         projects.add(task.jiraProject);
       }
     });
     return Array.from(projects).sort();
-  }, [filteredTasks]);
+  }, [regularTasks]);
 
   const availableJiraTypes = useMemo(() => {
     const types = new Set<string>();
-    filteredTasks.forEach(task => {
+    regularTasks.forEach(task => {
       if (task.source === 'jira' && task.jiraType) {
         types.add(task.jiraType);
       }
     });
     return Array.from(types).sort();
-  }, [filteredTasks]);
+  }, [regularTasks]);
 
   // Calculer les compteurs pour les projets Jira
   const jiraProjectCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     availableJiraProjects.forEach(project => {
-      counts[project] = filteredTasks.filter(task => 
+      counts[project] = regularTasks.filter(task => 
         task.source === 'jira' && task.jiraProject === project
       ).length;
     });
     return counts;
-  }, [filteredTasks, availableJiraProjects]);
+  }, [regularTasks, availableJiraProjects]);
 
   // Calculer les compteurs pour les types Jira
   const jiraTypeCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     availableJiraTypes.forEach(type => {
-      counts[type] = filteredTasks.filter(task => 
+      counts[type] = regularTasks.filter(task => 
         task.source === 'jira' && task.jiraType === type
       ).length;
     });
     return counts;
-  }, [filteredTasks, availableJiraTypes]);
+  }, [regularTasks, availableJiraTypes]);
 
   const handleJiraToggle = (mode: 'show' | 'hide' | 'all') => {
     const updates: Partial<KanbanFilters> = {};
@@ -66,14 +66,19 @@ export function JiraFilters({ filters, onFiltersChange }: JiraFiltersProps) {
       case 'show':
         updates.showJiraOnly = true;
         updates.hideJiraTasks = false;
+        // Désactiver les filtres TFS conflictuels
+        updates.showTfsOnly = false;
         break;
       case 'hide':
         updates.showJiraOnly = false;
         updates.hideJiraTasks = true;
+        // Désactiver les filtres TFS conflictuels
+        updates.hideTfsTasks = false;
         break;
       case 'all':
         updates.showJiraOnly = false;
         updates.hideJiraTasks = false;
+        // Ne pas toucher aux filtres TFS
         break;
     }
     

src/components/kanban/filters/PriorityFilters.tsx

@@ -11,16 +11,16 @@ interface PriorityFiltersProps {
 }
 
 export function PriorityFilters({ selectedPriorities = [], onPriorityToggle }: PriorityFiltersProps) {
-  const { filteredTasks } = useTasksContext();
+  const { regularTasks } = useTasksContext();
 
-  // Calculer les compteurs pour les priorités basés sur les tâches filtrées
+  // Calculer les compteurs pour les priorités basés sur toutes les tâches
   const priorityCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     getAllPriorities().forEach(priority => {
-      counts[priority.key] = filteredTasks.filter(task => task.priority === priority.key).length;
+      counts[priority.key] = regularTasks.filter(task => task.priority === priority.key).length;
     });
     return counts;
-  }, [filteredTasks]);
+  }, [regularTasks]);
 
   const priorityOptions = getAllPriorities().map(priorityConfig => ({
     value: priorityConfig.key,

src/components/kanban/filters/TagFilters.tsx

@@ -9,16 +9,16 @@ interface TagFiltersProps {
 }
 
 export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps) {
-  const { tags: availableTags, filteredTasks } = useTasksContext();
+  const { tags: availableTags, regularTasks } = useTasksContext();
 
-  // Calculer les compteurs pour les tags basés sur les tâches filtrées
+  // Calculer les compteurs pour les tags basés sur toutes les tâches
   const tagCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     availableTags.forEach(tag => {
-      counts[tag.name] = filteredTasks.filter(task => task.tags?.includes(tag.name)).length;
+      counts[tag.name] = regularTasks.filter(task => task.tags?.includes(tag.name)).length;
     });
     return counts;
-  }, [filteredTasks, availableTags]);
+  }, [regularTasks, availableTags]);
 
   // Trier les tags par nombre d'utilisation (décroissant)
   const sortedTags = useMemo(() => {
@@ -29,8 +29,8 @@ export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps)
     });
   }, [availableTags, tagCounts]);
 
-  // Filtrer les tags qui ont des tâches visibles
+  // Montrer tous les tags disponibles (pas seulement ceux avec des tâches visibles)
-  const visibleTags = sortedTags.filter(tag => (tagCounts[tag.name] || 0) > 0);
+  const visibleTags = sortedTags;
 
   if (availableTags.length === 0) {
     return null;
@@ -43,7 +43,7 @@ export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps)
       </label>
       {visibleTags.length === 0 ? (
         <div className="text-xs text-[var(--muted-foreground)] italic">
-          Aucun tag disponible dans les tâches filtrées
+          Aucun tag disponible
         </div>
       ) : (
         <div className="flex flex-wrap gap-1 max-h-32 overflow-y-auto">

src/components/kanban/filters/TfsFilters.tsx

@@ -11,32 +11,32 @@ interface TfsFiltersProps {
 }
 
 export function TfsFilters({ filters, onFiltersChange }: TfsFiltersProps) {
-  const { regularTasks, filteredTasks } = useTasksContext();
+  const { regularTasks } = useTasksContext();
 
   // Vérifier s'il y a des tâches TFS dans le système (même masquées)
   const hasTfsTasks = regularTasks.some(task => task.source === 'tfs');
 
-  // Récupérer les projets TFS disponibles dans les tâches filtrées
+  // Récupérer les projets TFS disponibles dans toutes les tâches
   const availableTfsProjects = useMemo(() => {
     const projects = new Set<string>();
-    filteredTasks.forEach(task => {
+    regularTasks.forEach(task => {
       if (task.source === 'tfs' && task.tfsProject) {
         projects.add(task.tfsProject);
       }
     });
     return Array.from(projects).sort();
-  }, [filteredTasks]);
+  }, [regularTasks]);
 
   // Calculer les compteurs pour les projets TFS
   const tfsProjectCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     availableTfsProjects.forEach(project => {
-      counts[project] = filteredTasks.filter(task => 
+      counts[project] = regularTasks.filter(task => 
         task.source === 'tfs' && task.tfsProject === project
       ).length;
     });
     return counts;
-  }, [filteredTasks, availableTfsProjects]);
+  }, [regularTasks, availableTfsProjects]);
 
   const handleTfsToggle = (mode: 'show' | 'hide' | 'all') => {
     const updates: Partial<KanbanFilters> = {};
@@ -45,14 +45,19 @@ export function TfsFilters({ filters, onFiltersChange }: TfsFiltersProps) {
       case 'show':
         updates.showTfsOnly = true;
         updates.hideTfsTasks = false;
+        // Désactiver les filtres Jira conflictuels
+        updates.showJiraOnly = false;
         break;
       case 'hide':
         updates.showTfsOnly = false;
         updates.hideTfsTasks = true;
+        // Désactiver les filtres Jira conflictuels
+        updates.hideJiraTasks = false;
         break;
       case 'all':
         updates.showTfsOnly = false;
         updates.hideTfsTasks = false;
+        // Ne pas toucher aux filtres Jira
         break;
     }