@silvestv/migration-planificator 6.0.0 → 6.0.2

package/dist/src/core/ast/matchers/ts/symbol-matcher.js

@@ -139,7 +139,7 @@ function resolveSpecifierOneLevel(specifier) {
 /**
  * Vérifie si un nœud référence un symbole qui correspond au pattern referTo
  * @param node Nœud à vérifier (généralement un Identifier dans un tableau providers)
- * @param referToPattern Pattern de référence (decorator, propertyNotEqual, etc.)
+ * @param referToPattern Pattern de référence (decorator, propertyNotEqual, functionBody, etc.)
  * @returns true si le symbole référencé matche le pattern
  */
 function matchesReferTo(node, referToPattern) {
@@ -149,7 +149,20 @@ function matchesReferTo(node, referToPattern) {
     const definitions = identifierNode.getDefinitionNodes();
     if (definitions.length === 0)
         return false;
-    return definitions.some((def) => matchesDefinition(def, referToPattern));
+    return definitions.some((def) => {
+        // Mode existant : décorateur de classe
+        if (referToPattern.decorator) {
+            return matchesDefinition(def, referToPattern);
+        }
+        // NOUVEAU : analyse du body de fonction (guards fonctionnels)
+        if (referToPattern.functionBody) {
+            const body = resolveToFunctionBody(def);
+            if (!body)
+                return false;
+            return checkFunctionBodyMatch(body, referToPattern.functionBody);
+        }
+        return false;
+    });
 }
 /**
  * Extrait le nœud Identifier du nœud donné selon le pattern
@@ -279,3 +292,86 @@ function checkPropertyNotEqual(decorator, propertyNotEqual) {
     const actualValue = propValue.getText().replace(/['"]/g, '');
     return actualValue !== value;
 }
+/**
+ * Résout une définition vers le body d'une ArrowFunction ou FunctionExpression
+ * Pour les guards fonctionnels (CanActivateFn, etc.)
+ * @param def - Définition (peut être ImportSpecifier, ExportSpecifier ou VariableDeclaration)
+ * @returns Body de la fonction ou undefined
+ */
+function resolveToFunctionBody(def) {
+    let targetNode = def;
+    // Si c'est un Import/ExportSpecifier, résoudre récursivement
+    if ((0, ast_helpers_1.isImportOrExportSpecifier)(def)) {
+        targetNode = resolveSpecifierRecursively(def);
+    }
+    // Si c'est une VariableDeclaration, extraire l'initializer
+    if (ts_morph_1.Node.isVariableDeclaration(targetNode)) {
+        const initializer = targetNode.getInitializer();
+        if (initializer && (ts_morph_1.Node.isArrowFunction(initializer) || ts_morph_1.Node.isFunctionExpression(initializer))) {
+            return initializer.getBody();
+        }
+    }
+    // Si c'est directement une ArrowFunction ou FunctionExpression
+    if (ts_morph_1.Node.isArrowFunction(targetNode) || ts_morph_1.Node.isFunctionExpression(targetNode)) {
+        return targetNode.getBody();
+    }
+    return undefined;
+}
+/**
+ * Vérifie si le body d'une fonction contient les patterns recherchés
+ * @param body - Body de la fonction à analyser
+ * @param pattern - Pattern avec contains et/ou hasConditional
+ * @returns true si le body matche le pattern
+ */
+function checkFunctionBodyMatch(body, pattern) {
+    let hasContains = true;
+    let hasConditional = true;
+    // Vérifier contains.functionName
+    if (pattern.contains?.functionName) {
+        const funcNames = Array.isArray(pattern.contains.functionName)
+            ? pattern.contains.functionName
+            : [pattern.contains.functionName];
+        hasContains = false;
+        body.forEachDescendant((child) => {
+            if (hasContains)
+                return; // Early exit si déjà trouvé
+            if (ts_morph_1.Node.isCallExpression(child)) {
+                const expr = child.getExpression();
+                const name = expr.getText().split('.').pop() || '';
+                if (funcNames.includes(name)) {
+                    hasContains = true;
+                }
+            }
+        });
+        if (!hasContains)
+            return false;
+    }
+    // Vérifier hasConditional (?: || && if)
+    if (pattern.hasConditional) {
+        hasConditional = false;
+        body.forEachDescendant((child) => {
+            if (hasConditional)
+                return; // Early exit si déjà trouvé
+            // Ternaire ? :
+            if (ts_morph_1.Node.isConditionalExpression(child)) {
+                hasConditional = true;
+                return;
+            }
+            // if statement
+            if (ts_morph_1.Node.isIfStatement(child)) {
+                hasConditional = true;
+                return;
+            }
+            // Opérateurs logiques || &&
+            if (ts_morph_1.Node.isBinaryExpression(child)) {
+                const op = child.getOperatorToken().getText();
+                if (op === '||' || op === '&&') {
+                    hasConditional = true;
+                }
+            }
+        });
+        if (!hasConditional)
+            return false;
+    }
+    return hasContains && hasConditional;
+}

package/dist/src/core/ast/matchers/ts/type-matcher.js

@@ -139,11 +139,14 @@ function matchesInitializer(node, initializerPattern, matchesAstPatternFn) {
     if (!initializer) {
         return false;
     }
-    // Vérifier notWrappedIn
+    // Vérifier notWrappedIn (support string ou array)
     if (initializerPattern.notWrappedIn) {
         if (ts_morph_1.Node.isCallExpression(initializer)) {
             const funcName = initializer.getExpression().getText();
-            if (funcName === initializerPattern.notWrappedIn) {
+            const wrappers = Array.isArray(initializerPattern.notWrappedIn)
+                ? initializerPattern.notWrappedIn
+                : [initializerPattern.notWrappedIn];
+            if (wrappers.includes(funcName)) {
                 return false;
             }
         }

package/dist/src/core/ast/matchers/utils/matcher-helpers.js

@@ -7,6 +7,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureArray = ensureArray;
 exports.normalizeValue = normalizeValue;
 exports.matchesTextValue = matchesTextValue;
+exports.stripQuotes = stripQuotes;
+exports.extractVariableNames = extractVariableNames;
+exports.hasExplicitFunctionCall = hasExplicitFunctionCall;
 /**
  * Normalise une valeur en tableau
  * @param value Valeur simple ou tableau
@@ -35,3 +38,60 @@ function matchesTextValue(nodeText, expectedValue) {
         nodeText === `"${expectedValue}"` ||
         nodeText === `${expectedValue}`;
 }
+/**
+ * Enlève les quotes simples ou doubles autour d'une string
+ * Utile pour computed properties: "'[class.active]'" → "[class.active]"
+ * @param str String potentiellement quotée
+ * @returns String sans quotes
+ */
+function stripQuotes(str) {
+    if ((str.startsWith("'") && str.endsWith("'")) || (str.startsWith('"') && str.endsWith('"'))) {
+        return str.slice(1, -1);
+    }
+    return str;
+}
+/**
+ * Extrait tous les noms de variables d'une expression de binding
+ * Exemples:
+ *   'isActive' → ['isActive']
+ *   'count > 0' → ['count']
+ *   'count1 + count2' → ['count1', 'count2']
+ *   'sig() ? "a" : "b"' → ['sig']
+ *   'obj.prop' → ['obj']
+ * @param expression Expression de binding
+ * @returns Array de noms de variables
+ */
+function extractVariableNames(expression) {
+    const cleaned = expression.trim();
+    const variables = new Set();
+    // Pattern pour extraire tous les identifiants valides
+    const identifierPattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
+    const matches = cleaned.matchAll(identifierPattern);
+    // Mots-clés JavaScript à exclure
+    const keywords = new Set([
+        'true', 'false', 'null', 'undefined', 'this',
+        'if', 'else', 'for', 'while', 'return', 'function',
+        'const', 'let', 'var', 'new', 'typeof', 'instanceof'
+    ]);
+    for (const match of matches) {
+        const varName = match[1];
+        if (!keywords.has(varName)) {
+            variables.add(varName);
+        }
+    }
+    return Array.from(variables);
+}
+/**
+ * Détecte si une expression contient un appel de fonction explicite pour une variable
+ * Exemples:
+ *   'isActive' → false
+ *   'isActive()' → true
+ *   'sig() ? "a" : "b"' → true (pour 'sig')
+ * @param expression Expression à tester
+ * @param variableName Nom de la variable
+ * @returns true si appel de fonction détecté
+ */
+function hasExplicitFunctionCall(expression, variableName) {
+    const regex = new RegExp(`\\b${variableName}\\s*\\(`);
+    return regex.test(expression);
+}

package/dist/src/core/ast/matchers/utils/template-cache.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTemplateCache = clearTemplateCache;
+exports.getTemplateFromCache = getTemplateFromCache;
+exports.setTemplateInCache = setTemplateInCache;
+/**
+ * Cache LRU pour templates HTML externes (templateUrl)
+ * Réutilisé par decorator-matcher et host-binding-property-matcher
+ * Principe DRY: une seule implémentation
+ */
+class TemplateCache {
+    cache = new Map();
+    maxSize = 100;
+    get(filePath) {
+        return this.cache.get(filePath);
+    }
+    set(filePath, content) {
+        // LRU: si cache plein, supprimer le plus ancien
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(filePath, content);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+// Instance globale du cache (partagée entre tous les matchers)
+const templateCache = new TemplateCache();
+/**
+ * Efface le cache des templates (pour tests ou libération mémoire)
+ */
+function clearTemplateCache() {
+    templateCache.clear();
+}
+/**
+ * Récupère un template depuis le cache
+ */
+function getTemplateFromCache(filePath) {
+    return templateCache.get(filePath);
+}
+/**
+ * Ajoute un template au cache
+ */
+function setTemplateInCache(filePath, content) {
+    templateCache.set(filePath, content);
+}

package/dist/src/core/project-detector.js

@@ -53,12 +53,14 @@ function detectProject(projectPath) {
     const hasAngularJson = fs.existsSync(angularJsonPath);
     const hasAppsDir = fs.existsSync(appsDir);
     const hasLibsDir = fs.existsSync(libsDir);
+    const hasProjectJsonAtRoot = fs.existsSync(path.join(projectPath, 'project.json'));
     let type = 'unknown';
     let appNames = [];
     let libNames = [];
     // Lire angular.json UNE SEULE FOIS si présent
     const angularJson = hasAngularJson ? readJsonFile(angularJsonPath) : null;
-    if (hasNxJson && hasAppsDir) {
+    // Nx monorepo : avec apps/ OU single-app (project.json à la racine)
+    if (hasNxJson && (hasAppsDir || hasProjectJsonAtRoot)) {
         type = 'nx-monorepo';
         appNames = extractNxApps(projectPath);
         libNames = hasLibsDir ? extractNxLibs(projectPath) : [];
@@ -116,17 +118,27 @@ function extractAngularProjects(angularJson) {
 }
 function extractNxApps(projectPath) {
     const appsDir = path.join(projectPath, 'apps');
-    if (!fs.existsSync(appsDir))
-        return [];
-    try {
-        return fs.readdirSync(appsDir, { withFileTypes: true })
-            .filter(entry => entry.isDirectory())
-            .filter(dir => fs.existsSync(path.join(appsDir, dir.name, 'project.json')))
-            .map(dir => dir.name);
+    // Cas standard : dossier apps/ existe
+    if (fs.existsSync(appsDir)) {
+        try {
+            return fs.readdirSync(appsDir, { withFileTypes: true })
+                .filter(entry => entry.isDirectory())
+                .filter(dir => fs.existsSync(path.join(appsDir, dir.name, 'project.json')))
+                .map(dir => dir.name);
+        }
+        catch {
+            return [];
+        }
     }
-    catch {
-        return [];
+    // Nx single-app : project.json à la racine + src/
+    const projectJsonPath = path.join(projectPath, 'project.json');
+    const srcDir = path.join(projectPath, 'src');
+    if (fs.existsSync(projectJsonPath) && fs.existsSync(srcDir)) {
+        const projectJson = readJsonFile(projectJsonPath);
+        const appName = projectJson?.name || path.basename(projectPath);
+        return [appName];
     }
+    return [];
 }
 function extractNxLibs(projectPath) {
     const libsDir = path.join(projectPath, 'libs');

package/dist/src/core/project-strategy/nx-strategy.js

@@ -38,7 +38,8 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 /**
  * Stratégie pour projets Nx Monorepo
- * - Structure apps/ et libs/
+ * - Structure apps/ et libs/ (standard)
+ * - Structure src/ à la racine (single-app Nx)
  * - Routines globales séparées des targets apps/libs
  * - Target "monorepo" pour règles de routine
  */
@@ -50,46 +51,46 @@ class NxStrategy {
         if (fs.existsSync(appPath)) {
             return appPath;
         }
-        return libPath;
+        if (fs.existsSync(libPath)) {
+            return libPath;
+        }
+        // Nx single-app : fallback vers src/
+        const srcPath = path.join(projectInfo.path, 'src');
+        if (fs.existsSync(srcPath)) {
+            return srcPath;
+        }
+        return appPath; // fallback original
     }
     getTargetType(projectInfo, targetName) {
-        // Si targetName === projectInfo.name ET projet a plusieurs apps/libs → target "monorepo"
-        const hasMultipleTargets = (projectInfo.apps?.length || 0) + (projectInfo.libs?.length || 0) > 1;
-        if (hasMultipleTargets && targetName === projectInfo.name) {
+        // Target monorepo = nom du projet (pour routines globales)
+        if (targetName === projectInfo.name) {
             return 'monorepo';
         }
-        // Vérifier dans les apps
-        if (projectInfo.apps?.some(app => app.name === targetName)) {
-            return 'app';
-        }
         // Vérifier dans les libs
         if (projectInfo.libs?.some(lib => lib.name === targetName)) {
             return 'lib';
         }
-        // Par défaut app
+        // Par défaut app (inclut Nx single-app)
         return 'app';
     }
     extractTargetFromFilePath(filePath, projectInfo) {
         const normalizedPath = filePath.replace(/\\/g, '/');
-        // Nx monorepo : apps/XXX ou libs/XXX (ou libs/groupe/XXX pour structure groupée)
+        // Nx standard : apps/XXX ou libs/XXX (ou libs/groupe/XXX pour structure groupée)
         const appsMatch = normalizedPath.match(/^apps\/([^\/]+)/);
         if (appsMatch)
             return appsMatch[1];
         // Support libs groupées : libs/apis/git-platform → "apis/git-platform"
         const libsMatch = normalizedPath.match(/^libs\/(.*?)(?:\/|$)/);
         if (libsMatch) {
-            // Extraire tout le chemin après libs/ jusqu'au premier fichier
             const fullLibPath = normalizedPath.substring(5); // Enlever "libs/"
-            // Trouver la lib complète en cherchant dans projectInfo.libs
             const matchingLib = projectInfo.libs?.find(lib => fullLibPath.startsWith(lib.name));
-            if (matchingLib) {
-                return matchingLib.name; // Ex: "apis/git-platform"
-            }
-            // Fallback : prendre premier segment (ancien comportement)
-            return libsMatch[1];
+            return matchingLib?.name || libsMatch[1];
+        }
+        // Nx single-app : src/... → nom de l'app (premier de la liste)
+        if (normalizedPath.startsWith('src/')) {
+            return projectInfo.apps?.[0]?.name || projectInfo.name;
         }
-        // Si le chemin ne correspond pas à apps/ ou libs/, c'est un fichier global (ex: package.json)
-        // Pour Nx monorepo, ces règles de routine vont dans le target "monorepo" (nom du projet)
+        // Fichiers racine (package.json, nx.json, etc.) → nom du projet (routines)
         return projectInfo.name;
     }
     shouldFilterRoutinesFromTarget(targetName, projectInfo) {
@@ -123,8 +124,10 @@ class NxStrategy {
         const libs = projectInfo.libs || [];
         return [...apps, ...libs];
     }
-    isMultiTarget(projectInfo) {
-        return ((projectInfo.apps?.length || 0) + (projectInfo.libs?.length || 0)) > 1;
+    isMultiTarget(_projectInfo) {
+        // Nx = toujours multi-target pour afficher l'UI complète
+        // même avec 1 seule app (affiche strate Monorepo)
+        return true;
     }
 }
 exports.NxStrategy = NxStrategy;

package/dist/src/data/angular-migration-rules.json

@@ -356,32 +356,53 @@
     ],
     "recommande": [
       {
-        "key": "redirectTo_function",
-        "summary": "redirectTo peut maintenant être une fonction",
-        "description": "La propriété redirectTo dans les routes Angular peut maintenant accepter une fonction en plus des strings, permettant des redirections dynamiques basées sur l'état de l'application. Cette fonctionnalité est optionnelle mais recommandée pour plus de flexibilité.",
-        "estimated_time_per_occurrence": 5,
-        "onFile": null,
+        "key": "guard_redirect_to_function",
+        "summary": "Guard de redirection conditionnelle → utiliser redirectTo fonction",
+        "description": "Angular 18 permet d'utiliser redirectTo comme fonction. Les guards qui redirigent conditionnellement via createUrlTree peuvent être simplifiés en redirectTo fonction, éliminant le besoin de guard et d'injection de Router.",
+        "estimated_time_per_occurrence": 8,
         "fileTypes": [
           "*.ts"
         ],
-        "regex": "redirectTo\\s*:\\s*['\"]",
+        "regex": "canActivate\\s*:\\s*\\[[^\\]]*createUrlTree[^\\]]*\\?|canActivate\\s*:\\s*\\[[^\\]]*\\?[^\\]]*createUrlTree",
         "category": "routing",
         "isAutoFixable": false,
-        "migration_command": null,
         "risk_level": "low",
-        "code_description": "// Avant:\nredirectTo: '/new'\n\n// Après (optionnel):\nredirectTo: () => '/new'",
+        "code_description": "// Avant (guard de redirection conditionnelle):\n{\n  path: '',\n  canActivate: [() => {\n    return inject(AuthService).isAdmin()\n      ? inject(Router).createUrlTree(['/admin'])\n      : inject(Router).createUrlTree(['/user']);\n  }]\n}\n\n// Après (redirectTo fonction):\n{\n  path: '',\n  redirectTo: () => inject(AuthService).isAdmin() ? '/admin' : '/user'\n}",
         "astPattern": {
           "nodeType": "PropertyAssignment",
-          "name": "redirectTo",
+          "name": ["canActivate", "canActivateChild", "canMatch"],
           "initializer": {
-            "nodeType": "StringLiteral"
+            "nodeType": "ArrayLiteralExpression",
+            "elements": {
+              "containsAny": [
+                {
+                  "nodeType": "ArrowFunction",
+                  "body": {
+                    "contains": {
+                      "functionName": "createUrlTree"
+                    }
+                  }
+                },
+                {
+                  "nodeType": "Identifier",
+                  "referTo": {
+                    "functionBody": {
+                      "contains": {
+                        "functionName": "createUrlTree"
+                      },
+                      "hasConditional": true
+                    }
+                  }
+                }
+              ]
+            }
           },
           "excludeContext": [
             "StringLiteral",
             "Comment"
           ]
         },
-        "doc_url": "https://angular.dev/reference/migrations"
+        "doc_url": "https://angular.dev/guide/routing/redirecting-routes"
       },
       {
         "key": "zoneless_ts_provider",
@@ -543,34 +564,6 @@
           ]
         },
         "doc_url": "https://angular.dev/guide/ssr#hydration"
-      },
-      {
-        "key": "forms_events_unified",
-        "summary": "Utiliser control.events unifié",
-        "description": "L'API control.events unifie valueChanges et statusChanges en un seul stream d'événements typés, simplifiant la gestion des changements de formulaires et offrant plus de types d'événements (PristineChangeEvent, TouchedChangeEvent, etc.).",
-        "estimated_time_per_occurrence": 5,
-        "onFile": null,
-        "fileTypes": [
-          "*.ts"
-        ],
-        "regex": "\\.(valueChanges|statusChanges)[!?]?\\s*(?:\\.[\\s\\S]*?pipe\\([^)]*\\))?\\s*[\\n\\r\\s]*\\.?subscribe",
-        "category": "forms",
-        "isAutoFixable": false,
-        "migration_command": null,
-        "risk_level": "low",
-        "code_description": "// Avant:\ncontrol.valueChanges.subscribe(v => {});\ncontrol.statusChanges.subscribe(s => {});\n\n// Après:\ncontrol.events.subscribe(event => {\n  if (event instanceof ValueChangeEvent) { }\n  if (event instanceof StatusChangeEvent) { }\n});",
-        "astPattern": {
-          "nodeType": "PropertyAccessExpression",
-          "propertyName": [
-            "valueChanges",
-            "statusChanges"
-          ],
-          "excludeContext": [
-            "StringLiteral",
-            "Comment"
-          ]
-        },
-        "doc_url": "https://angular.dev/reference/migrations"
       }
     ],
     "optionnelle": [
@@ -651,24 +644,6 @@
         },
         "doc_url": "https://angular.dev/guide/router#redirectcommand"
       },
-      {
-        "key": "ng_content_fallback",
-        "summary": "Utiliser fallback content dans ng-content",
-        "description": "Angular 18 permet de définir un contenu par défaut à l'intérieur de ng-content qui sera affiché si aucun contenu n'est projeté. Utile pour créer des composants avec des valeurs par défaut sans logique conditionnelle complexe.",
-        "estimated_time_per_occurrence": 3,
-        "onFile": null,
-        "fileTypes": [
-          "*.html",
-          "*.ts"
-        ],
-        "regex": "<ng-content[^>]*></ng-content>",
-        "category": "template",
-        "isAutoFixable": false,
-        "migration_command": null,
-        "risk_level": "low",
-        "code_description": "// Avant:\n<ng-content></ng-content>\n\n// Après:\n<ng-content>\n  <div class=\"default\">Contenu par défaut</div>\n</ng-content>",
-        "doc_url": "https://angular.dev/reference/migrations"
-      },
       {
         "key": "http_cache_auth",
         "summary": "Cache HTTP avec headers auth",

package/dist/src/data/rules/rearchitecture/rearchitecture-rules.json

@@ -62,5 +62,35 @@
     "risk_level": "medium",
     "code_description": "// Avant: fonction complexe (> 75 lignes)\nexport class UserService {\n  processUserData(user: User): ProcessedUser {\n    // 75+ lignes de logique\n    // - Validation\n    // - Transformation\n    // - Calculs\n    // - Formatage\n    // - Gestion erreurs\n    // ...\n  }\n}\n\n// Après: décomposition en fonctions plus petites\nexport class UserService {\n  processUserData(user: User): ProcessedUser {\n    const validated = this.validateUser(user);\n    const transformed = this.transformUserData(validated);\n    const calculated = this.calculateMetrics(transformed);\n    return this.formatOutput(calculated);\n  }\n\n  private validateUser(user: User): ValidatedUser {\n    // Validation uniquement (~10 lignes)\n  }\n\n  private transformUserData(user: ValidatedUser): TransformedUser {\n    // Transformation uniquement (~15 lignes)\n  }\n\n  private calculateMetrics(user: TransformedUser): CalculatedUser {\n    // Calculs uniquement (~20 lignes)\n  }\n\n  private formatOutput(user: CalculatedUser): ProcessedUser {\n    // Formatage uniquement (~10 lignes)\n  }\n}\n\n// Bénéfices:\n// - Chaque fonction a une responsabilité unique\n// - Code plus lisible et maintenable\n// - Tests unitaires plus faciles\n// - Réutilisation possible des sous-fonctions",
     "doc_url": "https://angular.dev/style-guide#small-functions"
+  },
+  {
+    "key": "decouple_legacy_providers",
+    "summary": "Découpler les services fournis dans des modules ou composants",
+    "description": "Détecte les services Angular encore déclarés dans des tableaux `providers` d’un `@NgModule` ou d’un `@Component`. Depuis Angular standalone, il est recommandé que les services soient autonomes et marqués `providedIn: 'root'` pour être des singletons globaux. Les providers locaux créent des instances dupliquées et complexifient la gestion d’état.",
+    "estimated_time_per_occurrence": 25,
+    "onFile": null,
+    "fileTypes": ["*.ts"],
+    "regex": "@(?:NgModule|Component)\\s*\\([^)]*\\bproviders\\s*:\\s*\\[[^\\]]*\\]",
+    "category": "architecture",
+    "isAutoFixable": false,
+    "migration_command": null,
+    "risk_level": "high",
+    "code_description": "// Avant (ancien modèle):\n@NgModule({\n  providers: [UserService, AuthService]\n})\nexport class UserModule {}\n\n@Component({\n  selector: 'app-profile',\n  providers: [ProfileService]\n})\nexport class ProfileComponent {}\n\n// Après (standalone / moderne):\n@Injectable({ providedIn: 'root' })\nexport class UserService {}\n\n@Injectable({ providedIn: 'root' })\nexport class ProfileService {}\n\n// Puis retirer les providers des décorateurs.",
+    "astPattern": {
+      "nodeType": ["Identifier", "CallExpression"],
+      "context": "ProvidersArray",
+      "referTo": {
+        "decorator": "Injectable",
+        "elementNodeType": ["Identifier", "CallExpression"],
+        "propertyNotEqual": {
+          "key": "providedIn",
+          "value": "root"
+        }
+      },
+      "excludeContext": [
+        "StringLiteral",
+        "Comment"
+      ]
+    }
   }
 ]

package/dist/src/data/rules/to18/rules-18-obligatoire.json

@@ -301,7 +301,7 @@
   {
     "key": "onpush_host_bindings",
     "summary": "OnPush + host bindings nécessitent markForCheck()",
-    "description": "Avec OnPush change detection, les host bindings ne sont plus automatiquement mis à jour. Appeler manuellement markForCheck() après modification des propriétés utilisées dans les host bindings pour forcer la détection de changement.",
+    "description": "Avec OnPush change detection, les host bindings basés sur des propriétés simples ou getters ne sont plus automatiquement mis à jour. Les signals et computed() ont une détection de changement automatique. Appeler markForCheck() uniquement pour les propriétés simples et getters après leur modification.",
     "estimated_time_per_occurrence": 8,
     "onFile": null,
     "fileTypes": [
@@ -312,23 +312,17 @@
     "isAutoFixable": false,
     "migration_command": null,
     "risk_level": "high",
-    "code_description": "// Avant:\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class.active]': 'isActive' }\n})\ntoggle() { this.isActive = true; }\n\n// Après:\ntoggle() {\n  this.isActive = true;\n  this.cdr.markForCheck();\n}",
+    "code_description": "// Avant (propriété simple - NÉCESSITE markForCheck):\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class.active]': 'isActive' }\n})\nexport class MyComponent {\n  isActive = false;\n  toggle() { this.isActive = true; }\n}\n\n// Après:\ntoggle() {\n  this.isActive = true;\n  this.cdr.markForCheck();\n}\n\n// OK (signal - PAS BESOIN de markForCheck):\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class.active]': 'isActive()' }\n})\nexport class MyComponent {\n  isActive = signal(false);\n  toggle() { this.isActive.set(true); }\n}\n\n// OK (@HostBinding avec signal):\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class MyComponent {\n  @HostBinding('class.active')\n  isActive = signal(false);\n}\n\n// NÉCESSITE markForCheck (multi-variables):\n@Component({\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class.visible]': 'count1 + count2 > 0' }\n})\nexport class MyComponent {\n  count1 = 0;\n  count2 = 0;\n}",
     "astPattern": {
       "nodeType": "Decorator",
       "name": "Component",
       "properties": {
-        "changeDetection": "ChangeDetectionStrategy.OnPush",
-        "host": {
-          "containsAny": [
-            {
-              "nodeType": "StringLiteral",
-              "valueMatches": "\\[.*\\]"
-            },
-            {
-              "nodeType": "StringLiteral",
-              "valueMatches": "\\(.*\\)"
-            }
-          ]
+        "changeDetection": "ChangeDetectionStrategy.OnPush"
+      },
+      "hostBindingProperty": {
+        "bindingType": "property",
+        "resolvedProperty": {
+          "notWrappedIn": ["signal", "computed", "inject"]
         }
       },
       "excludeContext": [