refactor: update filters to use filteredTasks instead of regularTasks

- Modified `JiraFilters`, `PriorityFilters`, `TagFilters`, and `TfsFilters` components to utilize `filteredTasks` for better accuracy in task filtering.
- Adjusted logic to ensure that available projects, types, and counts are based on the currently filtered tasks, enhancing the relevance of displayed options.

src/components/kanban/filters/JiraFilters.tsx

@@ -11,31 +11,31 @@ interface JiraFiltersProps {
 }
 
 export function JiraFilters({ filters, onFiltersChange }: JiraFiltersProps) {
-  const { regularTasks } = useTasksContext();
+  const { regularTasks, filteredTasks } = 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 TOUTES les tâches
+  // Récupérer les projets et types Jira disponibles dans les tâches filtrées
   const availableJiraProjects = useMemo(() => {
     const projects = new Set<string>();
-    regularTasks.forEach(task => {
+    filteredTasks.forEach(task => {
       if (task.source === 'jira' && task.jiraProject) {
         projects.add(task.jiraProject);
       }
     });
     return Array.from(projects).sort();
-  }, [regularTasks]);
+  }, [filteredTasks]);
 
   const availableJiraTypes = useMemo(() => {
     const types = new Set<string>();
-    regularTasks.forEach(task => {
+    filteredTasks.forEach(task => {
       if (task.source === 'jira' && task.jiraType) {
         types.add(task.jiraType);
       }
     });
     return Array.from(types).sort();
-  }, [regularTasks]);
+  }, [filteredTasks]);
 
   const handleJiraToggle = (mode: 'show' | 'hide' | 'all') => {
     const updates: Partial<KanbanFilters> = {};

src/components/kanban/filters/PriorityFilters.tsx

@@ -11,16 +11,16 @@ interface PriorityFiltersProps {
 }
 
 export function PriorityFilters({ selectedPriorities = [], onPriorityToggle }: PriorityFiltersProps) {
-  const { regularTasks } = useTasksContext();
+  const { filteredTasks } = useTasksContext();
 
-  // Calculer les compteurs pour les priorités
+  // Calculer les compteurs pour les priorités basés sur les tâches filtrées
   const priorityCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     getAllPriorities().forEach(priority => {
-      counts[priority.key] = regularTasks.filter(task => task.priority === priority.key).length;
+      counts[priority.key] = filteredTasks.filter(task => task.priority === priority.key).length;
     });
     return counts;
-  }, [regularTasks]);
+  }, [filteredTasks]);
 
   const priorityOptions = getAllPriorities().map(priorityConfig => ({
     value: priorityConfig.key,
@@ -29,13 +29,21 @@ export function PriorityFilters({ selectedPriorities = [], onPriorityToggle }: P
     count: priorityCounts[priorityConfig.key] || 0
   }));
 
+  // Filtrer les priorités qui ont des tâches visibles
+  const visiblePriorities = priorityOptions.filter(priority => priority.count > 0);
+
   return (
     <div className="space-y-2">
       <label className="block text-xs font-mono font-medium text-[var(--muted-foreground)] uppercase tracking-wider">
         Priorités
       </label>
+      {visiblePriorities.length === 0 ? (
+        <div className="text-xs text-[var(--muted-foreground)] italic">
+          Aucune priorité disponible dans les tâches filtrées
+        </div>
+      ) : (
         <div className="flex flex-wrap gap-1">
-        {priorityOptions.filter(priority => priority.count > 0).map((priority) => (
+          {visiblePriorities.map((priority) => (
           <button
             key={priority.value}
             onClick={() => onPriorityToggle(priority.value)}
@@ -53,6 +61,7 @@ export function PriorityFilters({ selectedPriorities = [], onPriorityToggle }: P
           </button>
         ))}
         </div>
+      )}
     </div>
   );
 }

src/components/kanban/filters/TagFilters.tsx

@@ -9,16 +9,16 @@ interface TagFiltersProps {
 }
 
 export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps) {
-  const { tags: availableTags, regularTasks } = useTasksContext();
+  const { tags: availableTags, filteredTasks } = useTasksContext();
 
-  // Calculer les compteurs pour les tags
+  // Calculer les compteurs pour les tags basés sur les tâches filtrées
   const tagCounts = useMemo(() => {
     const counts: Record<string, number> = {};
     availableTags.forEach(tag => {
-      counts[tag.name] = regularTasks.filter(task => task.tags?.includes(tag.name)).length;
+      counts[tag.name] = filteredTasks.filter(task => task.tags?.includes(tag.name)).length;
     });
     return counts;
-  }, [regularTasks, availableTags]);
+  }, [filteredTasks, availableTags]);
 
   // Trier les tags par nombre d'utilisation (décroissant)
   const sortedTags = useMemo(() => {
@@ -29,6 +29,9 @@ export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps)
     });
   }, [availableTags, tagCounts]);
 
+  // Filtrer les tags qui ont des tâches visibles
+  const visibleTags = sortedTags.filter(tag => (tagCounts[tag.name] || 0) > 0);
+
   if (availableTags.length === 0) {
     return null;
   }
@@ -38,8 +41,13 @@ export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps)
       <label className="block text-xs font-mono font-medium text-[var(--muted-foreground)] uppercase tracking-wider">
         Tags
       </label>
+      {visibleTags.length === 0 ? (
+        <div className="text-xs text-[var(--muted-foreground)] italic">
+          Aucun tag disponible dans les tâches filtrées
+        </div>
+      ) : (
         <div className="flex flex-wrap gap-1 max-h-32 overflow-y-auto">
-        {sortedTags.filter(tag => (tagCounts[tag.name] || 0) > 0).map((tag) => (
+          {visibleTags.map((tag) => (
           <button
             key={tag.id}
             onClick={() => onTagToggle(tag.name)}
@@ -57,6 +65,7 @@ export function TagFilters({ selectedTags = [], onTagToggle }: TagFiltersProps)
           </button>
         ))}
         </div>
+      )}
     </div>
   );
 }

src/components/kanban/filters/TfsFilters.tsx

@@ -11,21 +11,21 @@ interface TfsFiltersProps {
 }
 
 export function TfsFilters({ filters, onFiltersChange }: TfsFiltersProps) {
-  const { regularTasks } = useTasksContext();
+  const { regularTasks, filteredTasks } = 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 TOUTES les tâches
+  // Récupérer les projets TFS disponibles dans les tâches filtrées
   const availableTfsProjects = useMemo(() => {
     const projects = new Set<string>();
-    regularTasks.forEach(task => {
+    filteredTasks.forEach(task => {
       if (task.source === 'tfs' && task.tfsProject) {
         projects.add(task.tfsProject);
       }
     });
     return Array.from(projects).sort();
-  }, [regularTasks]);
+  }, [filteredTasks]);
 
   const handleTfsToggle = (mode: 'show' | 'hide' | 'all') => {
     const updates: Partial<KanbanFilters> = {};