Oui, c'est tout à fait possible et c'est même une excellente suggestion ! Modifier l'ordre des opérations pour supprimer les mots-clés avant de traiter les années pourrait résoudre efficacement ce problème.
Voici comment nous pourrions restructurer la fonction cleanFileName :
export function cleanFileName(
name: string,
keywordsPart: string[],
keywordsFull: string[],
includeParentFolder = "",
): { cleanName: string; year: string } {
writeDebugLog("CLEAN_FILENAME", `Début du nettoyage pour: "${name}"`)
let cleanName = name
let year = ""
// ÉTAPE 1: Supprimer les mots-clés de type "part" (sous-chaînes)
for (const keyword of keywordsPart) {
const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
const beforeClean = cleanName
cleanName = cleanName.replace(new RegExp(escapedKeyword, "gi"), "")
if (beforeClean !== cleanName) {
writeDebugLog("CLEAN_FILENAME", `Mot-clé part "${keyword}" supprimé: "${beforeClean}" -> "${cleanName}"`)
}
}
writeDebugLog("CLEAN_FILENAME", `Après suppression des mots-clés part: "${cleanName}"`)
// ÉTAPE 2: Supprimer les mots-clés de type "full" (mots entiers)
for (const keyword of keywordsFull) {
const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
const beforeClean = cleanName
// Cas spécial: mot-clé suivi directement par une parenthèse
const parenthesisPattern = new RegExp(`${escapedKeyword}\\.?\\(`, "i")
if (parenthesisPattern.test(cleanName)) {
// Remplacer le mot-clé suivi d'un point et d'une parenthèse
cleanName = cleanName.replace(new RegExp(`${escapedKeyword}\\.\\(`, "gi"), ".(")
// Remplacer le mot-clé suivi directement d'une parenthèse
cleanName = cleanName.replace(new RegExp(`${escapedKeyword}\\(`, "gi"), "(")
}
// Approche standard pour les autres cas
cleanName = cleanName.replace(new RegExp(`(^|[^a-zA-Z0-9])${escapedKeyword}([^a-zA-Z0-9]|$)`, "gi"), "$1$2")
// Nettoyer les caractères consécutifs qui pourraient résulter de cette suppression
cleanName = cleanName.replace(/\.+/g, ".") // Points consécutifs
cleanName = cleanName.replace(/\s+/g, " ") // Espaces consécutifs
if (beforeClean !== cleanName) {
writeDebugLog("CLEAN_FILENAME", `Mot-clé full "${keyword}" supprimé: "${beforeClean}" -> "${cleanName}"`)
}
}
writeDebugLog("CLEAN_FILENAME", `Après suppression des mots-clés full: "${cleanName}"`)
// ÉTAPE 3: Extraire TOUTES les années possibles avec leur position
const yearsWithPositions = []
// Chercher les années entre parenthèses
const yearsInParenthesesMatches = [...cleanName.matchAll(/$$(\d{4})$$/g)]
for (const match of yearsInParenthesesMatches) {
yearsWithPositions.push({
year: match[1],
position: match.index || 0,
inParentheses: true,
})
writeDebugLog("CLEAN_FILENAME", `Année trouvée entre parenthèses: "${match[1]}" à la position ${match.index}`)
}
// Chercher les années isolées (19xx ou 20xx)
const isolatedYearsMatches = [...cleanName.matchAll(/\b(19\d{2}|20\d{2})\b/g)]
for (const match of isolatedYearsMatches) {
// Vérifier si cette année n'est pas déjà comptée comme étant entre parenthèses
const alreadyCounted = yearsWithPositions.some((y) => y.year === match[1] && y.position === match.index)
if (!alreadyCounted) {
yearsWithPositions.push({
year: match[1],
position: match.index || 0,
inParentheses: false,
})
writeDebugLog("CLEAN_FILENAME", `Année isolée trouvée: "${match[1]}" à la position ${match.index}`)
}
}
// Trier les années par position (de gauche à droite)
yearsWithPositions.sort((a, b) => a.position - b.position)
writeDebugLog("CLEAN_FILENAME", `Années trouvées (triées par position): ${JSON.stringify(yearsWithPositions)}`)
// ÉTAPE 4: Sélectionner l'année la plus à droite pour l'ajouter à la fin
if (yearsWithPositions.length > 0) {
// Prendre l'année la plus à droite
const rightmostYear = yearsWithPositions[yearsWithPositions.length - 1]
year = rightmostYear.year
writeDebugLog("CLEAN_FILENAME", `Année la plus à droite sélectionnée: "${year}"`)
// Supprimer uniquement l'année la plus à droite du nom
if (rightmostYear.inParentheses) {
cleanName = cleanName.replace(`(${rightmostYear.year})`, "")
} else {
// Utiliser une regex plus robuste qui fonctionne avec les points
cleanName = cleanName.replace(new RegExp(`(^|\\.|\\s)${rightmostYear.year}(\\.|\\s|$)`, "g"), "$1$2")
// Nettoyer les points consécutifs qui pourraient résulter de cette suppression
cleanName = cleanName.replace(/\.+/g, ".")
}
writeDebugLog("CLEAN_FILENAME", `Après suppression de l'année la plus à droite: "${cleanName}"`)
}
// Le reste de la fonction reste inchangé...
// [...]Cette modification permettrait de supprimer les mots-clés avant de traiter les années, ce qui devrait résoudre le problème des mots-clés comme "beb" qui ne sont pas correctement supprimés lorsqu'ils sont suivis d'une parenthèse contenant une année.
Voulez-vous que j'implémente cette modification dans la fonction complète ?
Voilà ! J'ai modifié les fonctions cleanFileName et cleanParentFolderName pour supprimer les mots-clés avant de traiter les années. Cette modification devrait résoudre le problème des mots-clés comme "beb" qui ne sont pas correctement supprimés lorsqu'ils sont suivis d'une parenthèse.
L'ordre des opérations est maintenant :
Cette approche est plus logique car elle permet de nettoyer le texte des mots-clés indésirables avant d'analyser et de manipuler les années, ce qui évite les interférences entre ces deux processus.
Voulez-vous tester cette modification avec des exemples spécifiques pour vérifier qu'elle résout bien le problème ?