Build fixes

Author: Selcuk

src/components/PairwiseOverlapMatrix.tsx

@@ -130,60 +130,11 @@ const PairwiseOverlapMatrix: React.FC<PairwiseOverlapProps> = ({ fastaNames, fol
     return positionData;
   }, []);
 
-  // Load alignment data for selected alignments
-  const loadAlignmentData = useCallback(async () => {
-    if (selectedAlignments.length === 0) {
-      setAlignmentData([]);
-      setOverlapMatrix([]);
-      setTotalPositions(0);
-      return;
-    }
-
-    setLoading(true);
-    try {
-      const loadPromises = selectedAlignments.map(async (name) => {
-        const response = await fetch(`${folder}/${name}.fasta`);
-        if (!response.ok) {
-          throw new Error(`Failed to load ${name}.fasta`);
-        }
-        const text = await response.text();
-        const sequences = parseFasta(text);
-        const positionData = calculatePositionData(sequences);
-        
-        return {
-          name,
-          sequences,
-          positionData
-        };
-      });
-
-      const loadedData = await Promise.all(loadPromises);
-      setAlignmentData(loadedData);
-      calculateOverlapMatrix(loadedData);
-    } catch (error) {
-      console.error('Error loading alignment data:', error);
-    } finally {
-      setLoading(false);
-    }
-  }, [selectedAlignments, folder, calculatePositionData, calculateOverlapMatrix]);
-
-  // Check if two amino acids are similar based on matching groups
-  const areSimilar = useCallback((aa1: string, aa2: string): boolean => {
-    if (aa1 === aa2) return true;
-    
-    for (const group of Object.values(matchingGroups)) {
-      if (group.includes(aa1) && group.includes(aa2)) {
-        return true;
-      }
-    }
-    return false;
-  }, []);
-
   // Calculate pairwise overlap matrix based on amino acid conservation
   const calculateOverlapMatrix = useCallback((data: AlignmentData[]) => {
     const n = data.length;
     const matrix: number[][] = Array(n).fill(null).map(() => Array(n).fill(0));
-    
+
     // Find the maximum position across all alignments
     const maxPos = Math.max(...data.map(d => 
       d.positionData.length > 0 ? Math.max(...d.positionData.map(p => p.position)) : 0
@@ -201,24 +152,24 @@ const PairwiseOverlapMatrix: React.FC<PairwiseOverlapProps> = ({ fastaNames, fol
         } else {
           // Off-diagonal: count positions where both alignments have similar conserved amino acids
           let sharedPositions = 0;
-          
+
           // Create position maps for quick lookup
           const posMapI = new Map<number, PositionData>();
           const posMapJ = new Map<number, PositionData>();
-          
+
           data[i].positionData.forEach(pos => posMapI.set(pos.position, pos));
           data[j].positionData.forEach(pos => posMapJ.set(pos.position, pos));
-          
+
           // Check all positions that exist in both alignments
           for (let pos = 0; pos <= maxPos; pos++) {
             const posDataI = posMapI.get(pos);
             const posDataJ = posMapJ.get(pos);
-            
+
             if (posDataI && posDataJ) {
               // Both alignments have data at this position
               const meetsThresholdI = posDataI.conservationFrequency >= conservationThreshold;
               const meetsThresholdJ = posDataJ.conservationFrequency >= conservationThreshold;
-              
+
               if (meetsThresholdI && meetsThresholdJ) {
                 // Check if the most conserved amino acids are similar
                 if (areSimilar(posDataI.mostConservedAA, posDataJ.mostConservedAA)) {
@@ -227,7 +178,7 @@ const PairwiseOverlapMatrix: React.FC<PairwiseOverlapProps> = ({ fastaNames, fol
               }
             }
           }
-          
+
           matrix[i][j] = sharedPositions;
         }
       }
@@ -236,6 +187,56 @@ const PairwiseOverlapMatrix: React.FC<PairwiseOverlapProps> = ({ fastaNames, fol
     setOverlapMatrix(matrix);
   }, [conservationThreshold, areSimilar]);
 
+  // Load alignment data for selected alignments
+  const loadAlignmentData = useCallback(async () => {
+    if (selectedAlignments.length === 0) {
+      setAlignmentData([]);
+      setOverlapMatrix([]);
+      setTotalPositions(0);
+      return;
+    }
+
+    setLoading(true);
+    try {
+      const loadPromises = selectedAlignments.map(async (name) => {
+        const response = await fetch(`${folder}/${name}.fasta`);
+        if (!response.ok) {
+          throw new Error(`Failed to load ${name}.fasta`);
+        }
+        const text = await response.text();
+        const sequences = parseFasta(text);
+        const positionData = calculatePositionData(sequences);
+        
+        return {
+          name,
+          sequences,
+          positionData
+        };
+      });
+
+      const loadedData = await Promise.all(loadPromises);
+      setAlignmentData(loadedData);
+      calculateOverlapMatrix(loadedData);
+    } catch (error) {
+      console.error('Error loading alignment data:', error);
+    } finally {
+      setLoading(false);
+    }
+  }, [selectedAlignments, folder, calculatePositionData, calculateOverlapMatrix]);
+
+  // Check if two amino acids are similar based on matching groups
+  const areSimilar = useCallback((aa1: string, aa2: string): boolean => {
+    if (aa1 === aa2) return true;
+    
+    for (const group of Object.values(matchingGroups)) {
+      if (group.includes(aa1) && group.includes(aa2)) {
+        return true;
+      }
+    }
+    return false;
+  }, []);
+
+
   // Load data when selected alignments or threshold changes
   useEffect(() => {
     loadAlignmentData();