@silvestv/migration-planificator 6.0.0 → 6.0.2

package/dist/src/core/app-analyzer.js

@@ -97,9 +97,17 @@ function extractPackageDeps(projectPath) {
  * Résout le chemin d'un target (app ou lib) selon le type de projet - DRY
  */
 function resolveTargetPath(targetName, projectPath, isNxMonorepo, nxFolder, angularJson) {
-    // Nx : apps/xxx ou libs/xxx
+    // Nx : apps/xxx ou libs/xxx (ou src/ pour single-app)
     if (isNxMonorepo) {
-        return path.join(projectPath, nxFolder, targetName);
+        const standardPath = path.join(projectPath, nxFolder, targetName);
+        // Nx single-app : si apps/xxx n'existe pas, utiliser src/
+        if (!fs.existsSync(standardPath) && nxFolder === 'apps') {
+            const srcPath = path.join(projectPath, 'src');
+            if (fs.existsSync(srcPath)) {
+                return srcPath;
+            }
+        }
+        return standardPath;
     }
     // Angular CLI : lire depuis angular.json si disponible
     const projectConfig = angularJson?.projects?.[targetName];

package/dist/src/core/ast/matchers/html/html-template-ref-collector.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTemplateReferences = collectTemplateReferences;
+const DEFER_SUB_BLOCKS = ['mainBlock', 'placeholder', 'loading', 'error'];
+/**
+ * Collecte toutes les template reference variables (#xxx) d'un template HTML
+ * Parcourt récursivement l'AST pour extraire les noms de références
+ */
+function collectTemplateReferences(nodes) {
+    const references = new Set();
+    traverse(nodes, references);
+    return references;
+}
+/**
+ * Parcourt récursivement les noeuds HTML pour collecter les références
+ */
+function traverse(nodeList, references) {
+    for (const node of nodeList) {
+        if (!node || typeof node !== 'object')
+            continue;
+        const anyNode = node;
+        // Element nodes ont un tableau references contenant les #xxx
+        extractReferencesFromNode(anyNode, references);
+        // Parcourir récursivement les enfants
+        traverseChildren(anyNode, references);
+        traverseBranches(anyNode, references);
+        traverseCases(anyNode, references);
+        traverseEmpty(anyNode, references);
+        traverseDeferBlocks(anyNode, references);
+    }
+}
+/**
+ * Extrait les références (#xxx) d'un noeud Element
+ */
+function extractReferencesFromNode(node, references) {
+    if (!Array.isArray(node.references))
+        return;
+    for (const ref of node.references) {
+        if (ref && typeof ref === 'object' && 'name' in ref && typeof ref.name === 'string') {
+            references.add(ref.name);
+        }
+    }
+}
+/**
+ * Parcourt les enfants directs d'un noeud
+ */
+function traverseChildren(node, references) {
+    if (Array.isArray(node.children)) {
+        traverse(node.children, references);
+    }
+}
+/**
+ * Parcourt les branches (@if, @else if, @else)
+ */
+function traverseBranches(node, references) {
+    if (!Array.isArray(node.branches))
+        return;
+    for (const branch of node.branches) {
+        if (branch && typeof branch === 'object' && Array.isArray(branch.children)) {
+            traverse(branch.children, references);
+        }
+    }
+}
+/**
+ * Parcourt les cases (@switch, @case, @default)
+ */
+function traverseCases(node, references) {
+    if (!Array.isArray(node.cases))
+        return;
+    for (const caseNode of node.cases) {
+        if (caseNode && typeof caseNode === 'object' && Array.isArray(caseNode.children)) {
+            traverse(caseNode.children, references);
+        }
+    }
+}
+/**
+ * Parcourt @for @empty
+ */
+function traverseEmpty(node, references) {
+    const empty = node.empty;
+    if (empty && Array.isArray(empty.children)) {
+        traverse(empty.children, references);
+    }
+}
+/**
+ * Parcourt les sous-blocs @defer (mainBlock, placeholder, loading, error)
+ */
+function traverseDeferBlocks(node, references) {
+    for (const blockName of DEFER_SUB_BLOCKS) {
+        const block = node[blockName];
+        if (block && Array.isArray(block.children)) {
+            traverse(block.children, references);
+        }
+    }
+}

package/dist/src/core/ast/matchers/html/html-text-matcher.js

@@ -2,51 +2,104 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchesBoundTextPattern = matchesBoundTextPattern;
 const html_parser_1 = require("./html-parser");
+const DEFAULT_TEMPLATE_REF_EXTRACT_PATTERN = '\\bthis\\.(\\w+)';
 /**
  * Matche un pattern BoundText (interpolations {{ ... }})
+ * @param node Noeud HTML à vérifier
+ * @param pattern Pattern AST à matcher
+ * @param htmlContent Contenu HTML complet (pour line numbers)
+ * @param templateRefs Set des template references (#xxx) du template (optionnel)
  */
-function matchesBoundTextPattern(node, pattern, htmlContent) {
+function matchesBoundTextPattern(node, pattern, htmlContent, templateRefs) {
     // Vérifier si c'est bien un BoundText (interpolation) et non un Text simple
-    if (!('value' in node) || !node.value || typeof node.value !== 'object') {
+    if (!isValidBoundTextNode(node)) {
         return null;
     }
     // Vérifier textMatches si spécifié
     if (!pattern.textMatches) {
         return null;
     }
-    const textRegex = new RegExp(pattern.textMatches);
-    // value.ast contient l'AST de l'expression (Interpolation, etc.)
-    const ast = node.value.ast;
-    // Si l'AST est une Interpolation avec expressions
-    if (ast && ast.expressions && Array.isArray(ast.expressions)) {
-        for (const expr of ast.expressions) {
-            // Pour LiteralPrimitive (mots-clés comme 'in')
-            if (expr.value !== undefined && typeof expr.value === 'string') {
-                if (textRegex.test(expr.value)) {
-                    return {
-                        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
-                        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
-                    };
-                }
-            }
-            // Pour VoidExpression (Angular parse 'void' comme opérateur)
-            if (expr.constructor && expr.constructor.name === 'VoidExpression') {
-                if (textRegex.test('void')) {
-                    return {
-                        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
-                        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
-                    };
-                }
-            }
+    const nodeValue = node.value;
+    const source = nodeValue.source;
+    // Validation templateRefVariable : vérifier que this.xxx est une template ref
+    if (pattern.templateRefVariable) {
+        if (!isValidTemplateRefMatch(source, pattern, templateRefs)) {
+            return null;
         }
     }
+    const textRegex = new RegExp(pattern.textMatches);
+    // Tester via AST expressions
+    const astMatch = matchViaAstExpressions(nodeValue.ast, textRegex, node, htmlContent);
+    if (astMatch) {
+        return astMatch;
+    }
     // Fallback: tester le source complet
-    if ('source' in node.value && typeof node.value.source === 'string') {
-        if (textRegex.test(node.value.source)) {
-            return {
-                lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
-                matchedText: node.value.source
-            };
+    if (source && textRegex.test(source)) {
+        return {
+            lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+            matchedText: source
+        };
+    }
+    return null;
+}
+/**
+ * Vérifie si le noeud est un BoundText valide avec une value object
+ */
+function isValidBoundTextNode(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    const nodeObj = node;
+    return 'value' in nodeObj && nodeObj.value !== null && typeof nodeObj.value === 'object';
+}
+/**
+ * Vérifie que this.xxx référence bien une template reference variable
+ * Retourne true si la validation passe (match autorisé), false sinon
+ */
+function isValidTemplateRefMatch(source, pattern, templateRefs) {
+    // Si pas de templateRefs fourni, on ne peut pas valider -> bloquer le match
+    if (!templateRefs || !source) {
+        return false;
+    }
+    const extractPattern = pattern.templateRefVariable?.extractPattern || DEFAULT_TEMPLATE_REF_EXTRACT_PATTERN;
+    const extractRegex = new RegExp(extractPattern);
+    const match = extractRegex.exec(source);
+    // Si pas de this.xxx trouvé ou variable pas dans les template refs -> pas de match
+    if (!match || !match[1]) {
+        return false;
+    }
+    const varName = match[1];
+    return templateRefs.has(varName);
+}
+/**
+ * Tente de matcher via les expressions AST (LiteralPrimitive, VoidExpression)
+ */
+function matchViaAstExpressions(ast, textRegex, node, htmlContent) {
+    if (!ast || typeof ast !== 'object')
+        return null;
+    const astObj = ast;
+    if (!astObj.expressions || !Array.isArray(astObj.expressions))
+        return null;
+    for (const expr of astObj.expressions) {
+        if (!expr || typeof expr !== 'object')
+            continue;
+        const exprObj = expr;
+        // Pour LiteralPrimitive (mots-clés comme 'in')
+        if (exprObj.value !== undefined && typeof exprObj.value === 'string') {
+            if (textRegex.test(exprObj.value)) {
+                return {
+                    lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+                    matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
+                };
+            }
+        }
+        // Pour VoidExpression (Angular parse 'void' comme opérateur)
+        if (exprObj.constructor?.name === 'VoidExpression') {
+            if (textRegex.test('void')) {
+                return {
+                    lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+                    matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
+                };
+            }
         }
     }
     return null;

package/dist/src/core/ast/matchers/html/index.js

@@ -9,14 +9,15 @@ const html_attribute_matcher_1 = require("./html-attribute-matcher");
 const html_element_matcher_1 = require("./html-element-matcher");
 const html_text_matcher_1 = require("./html-text-matcher");
 const html_pipe_matcher_1 = require("./html-pipe-matcher");
+const html_template_ref_collector_1 = require("./html-template-ref-collector");
 /**
  * Vérifie si un nœud HTML correspond à un pattern AST HTML
  * Supporte : Attribute, BoundAttribute, PipeExpression, BoundText, Element, DeferredBlock
  */
-function matchesHtmlNode(node, pattern, htmlContent) {
+function matchesHtmlNode(node, pattern, htmlContent, templateRefs) {
     // Pattern: BoundText (interpolations {{ ... }})
     if (pattern.nodeType === 'BoundText') {
-        return (0, html_text_matcher_1.matchesBoundTextPattern)(node, pattern, htmlContent);
+        return (0, html_text_matcher_1.matchesBoundTextPattern)(node, pattern, htmlContent, templateRefs);
     }
     // Pattern: Attribute (*ngIf, *ngFor, etc.) ou BoundAttribute ([ngClass], [ngStyle], etc.)
     if ((pattern.nodeType === 'Attribute' || pattern.nodeType === 'BoundAttribute') && (0, html_parser_1.isElement)(node)) {
@@ -39,10 +40,10 @@ function matchesHtmlNode(node, pattern, htmlContent) {
 /**
  * Parcourt récursivement l'AST HTML et trouve les matches
  */
-function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
+function traverseHtmlAst(nodes, pattern, htmlContent, matches, templateRefs) {
     for (const node of nodes) {
         // Vérifier si le nœud matche
-        const match = matchesHtmlNode(node, pattern, htmlContent);
+        const match = matchesHtmlNode(node, pattern, htmlContent, templateRefs);
         if (match) {
             matches.push(match);
         }
@@ -79,13 +80,13 @@ function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
         }
         // 1. Parcourir les enfants standards
         if ('children' in node && Array.isArray(node.children)) {
-            traverseHtmlAst(node.children, pattern, htmlContent, matches);
+            traverseHtmlAst(node.children, pattern, htmlContent, matches, templateRefs);
         }
         // 2. Parcourir les branches (@if, @else if, @else)
         if ('branches' in node && Array.isArray(node.branches)) {
             for (const branch of node.branches) {
                 if (branch.children && Array.isArray(branch.children)) {
-                    traverseHtmlAst(branch.children, pattern, htmlContent, matches);
+                    traverseHtmlAst(branch.children, pattern, htmlContent, matches, templateRefs);
                 }
             }
         }
@@ -93,13 +94,13 @@ function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
         if ('cases' in node && Array.isArray(node.cases)) {
             for (const caseNode of node.cases) {
                 if (caseNode.children && Array.isArray(caseNode.children)) {
-                    traverseHtmlAst(caseNode.children, pattern, htmlContent, matches);
+                    traverseHtmlAst(caseNode.children, pattern, htmlContent, matches, templateRefs);
                 }
             }
         }
         // 4. Parcourir @for @empty
         if ('empty' in node && node.empty?.children) {
-            traverseHtmlAst(node.empty.children, pattern, htmlContent, matches);
+            traverseHtmlAst(node.empty.children, pattern, htmlContent, matches, templateRefs);
         }
         // 4b. Parcourir @for expression (for PipeExpression like | keyvalue)
         if (pattern.nodeType === 'PipeExpression' && 'expression' in node && node.expression) {
@@ -116,7 +117,7 @@ function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
         const deferSubBlocks = ['mainBlock', 'placeholder', 'loading', 'error'];
         for (const blockName of deferSubBlocks) {
             if (blockName in node && node[blockName]?.children) {
-                traverseHtmlAst(node[blockName].children, pattern, htmlContent, matches);
+                traverseHtmlAst(node[blockName].children, pattern, htmlContent, matches, templateRefs);
             }
         }
     }
@@ -131,8 +132,13 @@ function findHtmlPatternMatches(htmlContent, pattern) {
     const matches = [];
     // Parser le template HTML
     const ast = (0, html_parser_1.parseHtmlTemplate)(htmlContent);
+    // Collecter les template refs si le pattern utilise templateRefVariable
+    let templateRefs;
+    if (pattern.templateRefVariable) {
+        templateRefs = (0, html_template_ref_collector_1.collectTemplateReferences)(ast);
+    }
     // Parcourir l'AST et trouver les matches
-    traverseHtmlAst(ast, pattern, htmlContent, matches);
+    traverseHtmlAst(ast, pattern, htmlContent, matches, templateRefs);
     return matches;
 }
 /**

package/dist/src/core/ast/matchers/index.js

@@ -61,6 +61,8 @@ exports.SymbolMatcher = SymbolMatcher;
 const HtmlMatcher = __importStar(require("./html"));
 exports.HtmlMatcher = HtmlMatcher;
 const html_pipe_variable_matcher_1 = require("./html/html-pipe-variable-matcher");
+const host_binding_property_matcher_1 = require("./ts/host-binding-property-matcher");
+const mutation_matcher_1 = require("./ts/mutation-matcher");
 /**
  * Fonction principale : vérifie si un nœud correspond à un pattern AST
  * OPTIMISÉ : excludeContext en premier (88% des règles l'utilisent)
@@ -206,12 +208,25 @@ function matchesAstPattern(node, pattern) {
             return false;
         }
     }
+    // Vérifier excludeModifiers
+    if (pattern.excludeModifiers !== undefined) {
+        if (!NodeMatcher.excludesModifiers(node, pattern.excludeModifiers)) {
+            return false;
+        }
+    }
     // Vérifier exported
     if (pattern.exported !== undefined) {
         if (!NodeMatcher.matchesExported(node, pattern.exported)) {
             return false;
         }
     }
+    // Vérifier isMutatedInClass (pour PropertyDeclaration)
+    if (pattern.isMutatedInClass !== undefined) {
+        const mutated = (0, mutation_matcher_1.isMutatedInClass)(node);
+        if (mutated !== pattern.isMutatedInClass) {
+            return false;
+        }
+    }
     // Vérifier parameters
     if (pattern.parameters !== undefined) {
         if (!DecoratorMatcher.matchesParameters(node, pattern.parameters)) {
@@ -377,6 +392,35 @@ function matchesAstPattern(node, pattern) {
             return false;
         }
     }
+    // Vérifier hostBindingProperty (résolution host binding → TS property → vérification wrappers)
+    if (pattern.hostBindingProperty !== undefined) {
+        if (!(0, host_binding_property_matcher_1.matchesHostBindingProperty)(node, pattern.hostBindingProperty)) {
+            return false;
+        }
+    }
+    // Vérifier fileMissing (identifiant absent de tout le fichier)
+    if (pattern.fileMissing !== undefined) {
+        const sourceFile = node.getSourceFile();
+        if (!FileMatcher.matchesFileMissing(sourceFile, pattern.fileMissing)) {
+            return false;
+        }
+    }
+    // Vérifier projectFileContains (cross-file avec fichiers config)
+    if (pattern.projectFileContains !== undefined) {
+        const sourceFile = node.getSourceFile();
+        if (!FileMatcher.matchesProjectFileContains(sourceFile, pattern.projectFileContains)) {
+            return false;
+        }
+    }
+    // Vérifier hasHostBindingDecorators (@HostBinding, @HostListener, ou host object literal dynamique)
+    // Utilise hasAnyHostBindings() de host-binding-property-matcher.ts (DRY)
+    if (pattern.hasHostBindingDecorators !== undefined) {
+        if (pattern.hasHostBindingDecorators === true) {
+            if (!(0, host_binding_property_matcher_1.hasAnyHostBindings)(node)) {
+                return false;
+            }
+        }
+    }
     return true;
 }
 // Export des fonctions utilitaires de cache

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

@@ -38,6 +38,10 @@ function matchesElements(node, elementsPattern, matchesAstPatternFn) {
     if (elementsPattern.contains) {
         return elements.some(element => matchesAstPatternFn(element, elementsPattern.contains));
     }
+    // Vérifier containsAny (au moins un élément matche l'un des patterns)
+    if (elementsPattern.containsAny && Array.isArray(elementsPattern.containsAny)) {
+        return elements.some(element => elementsPattern.containsAny.some((pattern) => matchesAstPatternFn(element, pattern)));
+    }
     // Cas où elementsPattern est directement un pattern AST
     return elements.some(element => matchesAstPatternFn(element, elementsPattern));
 }

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

@@ -190,11 +190,14 @@ function matchesNextProvider(node, nextProviderPattern) {
     if (currentIndex === -1) {
         return false;
     }
-    // Vérifier missing : le provider ne doit PAS être présent dans les éléments restants
+    // Vérifier missing : le provider ne doit PAS être présent dans le tableau entier
     if (nextProviderPattern.missing) {
         const missingProviderName = nextProviderPattern.missing;
-        // Vérifier tous les providers après le nœud courant
-        for (let i = currentIndex + 1; i < elements.length; i++) {
+        // Vérifier tous les providers du tableau (pas seulement ceux après le nœud courant)
+        for (let i = 0; i < elements.length; i++) {
+            // Ignorer le nœud courant lui-même
+            if (i === currentIndex)
+                continue;
             const providerElement = elements[i];
             const providerText = providerElement.getText();
             // Vérifier si le provider manquant est présent
@@ -203,7 +206,7 @@ function matchesNextProvider(node, nextProviderPattern) {
                 return false;
             }
         }
-        // Le provider est bien absent de tous les providers restants
+        // Le provider est bien absent de tous les autres providers
         return true;
     }
     return true;