@silvestv/migration-planificator 5.0.2 → 6.0.1

package/dist/src/config/migration.config.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Configuration centralisée des migrations Angular
+ * POINT D'ENTRÉE UNIQUE pour ajouter une nouvelle version (ex: to22)
+ *
+ * Pour ajouter une nouvelle migration :
+ * 1. Ajouter une entrée dans MIGRATION_CONFIGS
+ * 2. Créer le dossier src/data/rules/toXX/ avec les fichiers JSON
+ * 3. C'est tout ! Tous les autres fichiers s'adaptent automatiquement
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_LABEL_MAP = exports.MIGRATION_COLOR_MAP = exports.MIGRATION_ORDER = exports.MIGRATION_VERSIONS = exports.MIGRATION_CONFIGS = void 0;
+exports.getTargetVersionNumber = getTargetVersionNumber;
+exports.getMigrationConfig = getMigrationConfig;
+exports.isValidMigrationVersion = isValidMigrationVersion;
+/**
+ * LISTE ORDONNÉE des migrations supportées
+ * Pour ajouter to22 : ajouter UNE SEULE ligne ici
+ */
+exports.MIGRATION_CONFIGS = [
+    { version: 'to18', sourceVersion: 17, targetVersion: 18, label: 'Angular 17 → 18', color: 'blue' },
+    { version: 'to19', sourceVersion: 18, targetVersion: 19, label: 'Angular 18 → 19', color: 'indigo' },
+    { version: 'to20', sourceVersion: 19, targetVersion: 20, label: 'Angular 19 → 20', color: 'purple' },
+    { version: 'to21', sourceVersion: 20, targetVersion: 21, label: 'Angular 20 → 21', color: 'pink' },
+];
+// ============================================================================
+// UTILITAIRES DÉRIVÉS AUTOMATIQUEMENT
+// ============================================================================
+/**
+ * Liste des versions de migration (ex: ['to18', 'to19', 'to20', 'to21'])
+ */
+exports.MIGRATION_VERSIONS = exports.MIGRATION_CONFIGS.map(c => c.version);
+/**
+ * Ordre d'affichage des migrations (identique à MIGRATION_VERSIONS)
+ * Rétrocompatibilité avec core/workload/constants.ts
+ */
+exports.MIGRATION_ORDER = [...exports.MIGRATION_VERSIONS];
+/**
+ * Map version → couleur TailwindCSS
+ * Ex: { to18: 'blue', to19: 'indigo', to20: 'purple', to21: 'pink' }
+ */
+exports.MIGRATION_COLOR_MAP = Object.fromEntries(exports.MIGRATION_CONFIGS.map(c => [c.version, c.color]));
+/**
+ * Map version → label UI
+ * Ex: { to18: 'Angular 17 → 18', to19: 'Angular 18 → 19', ... }
+ */
+exports.MIGRATION_LABEL_MAP = Object.fromEntries(exports.MIGRATION_CONFIGS.map(c => [c.version, c.label]));
+// ============================================================================
+// HELPERS
+// ============================================================================
+/**
+ * Obtenir le numéro de version cible depuis un identifiant (ex: 'to21' → 21)
+ */
+function getTargetVersionNumber(version) {
+    const config = exports.MIGRATION_CONFIGS.find(c => c.version === version);
+    return config?.targetVersion ?? 0;
+}
+/**
+ * Obtenir la configuration complète d'une migration
+ */
+function getMigrationConfig(version) {
+    return exports.MIGRATION_CONFIGS.find(c => c.version === version);
+}
+/**
+ * Vérifie si une version est valide
+ */
+function isValidMigrationVersion(version) {
+    return exports.MIGRATION_VERSIONS.includes(version);
+}

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

@@ -41,94 +41,84 @@ const core_1 = require("../utils/core");
 /**
  * Analyse les détails d'une application Angular
  */
-function analyzeApp(appName, projectPath, isNxMonorepo) {
-    let appPath = projectPath;
-    if (isNxMonorepo) {
-        appPath = path.join(projectPath, 'apps', appName);
-    }
-    else {
-        const angularJsonPath = path.join(projectPath, 'angular.json');
-        if (fs.existsSync(angularJsonPath)) {
-            const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf-8'));
-            const appConfig = angularJson.projects?.[appName];
-            if (appConfig?.root) {
-                appPath = path.join(projectPath, appConfig.root);
-            }
-            else if (appConfig?.sourceRoot) {
-                appPath = path.join(projectPath, appConfig.sourceRoot);
-            }
-        }
-    }
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    let description;
-    let dependencies = 0;
-    let devDependencies = 0;
-    if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        description = packageJson.description;
-        dependencies = Object.keys(packageJson.dependencies || {}).length;
-        devDependencies = Object.keys(packageJson.devDependencies || {}).length;
-    }
-    const components = (0, core_1.countFiles)(appPath, /\.component\.ts$/);
-    const modules = (0, core_1.countFiles)(appPath, /\.module\.ts$/);
-    const services = (0, core_1.countFiles)(appPath, /\.service\.ts$/);
-    const directives = (0, core_1.countFiles)(appPath, /\.directive\.ts$/);
-    const pipes = (0, core_1.countFiles)(appPath, /\.pipe\.ts$/);
-    const guards = (0, core_1.countFiles)(appPath, /\.guard\.ts$/);
-    const interceptors = (0, core_1.countFiles)(appPath, /\.interceptor\.ts$/);
-    const resolvers = (0, core_1.countFiles)(appPath, /\.resolver\.ts$/);
+function analyzeApp(appName, projectPath, isNxMonorepo, angularJson) {
+    const appPath = resolveTargetPath(appName, projectPath, isNxMonorepo, 'apps', angularJson);
+    return analyzeTarget(appName, appPath, projectPath);
+}
+/**
+ * Analyse les détails d'une librairie Angular (Nx ou Angular CLI workspace)
+ */
+function analyzeLib(libName, projectPath, isNxMonorepo = true, angularJson) {
+    const libPath = resolveTargetPath(libName, projectPath, isNxMonorepo, 'libs', angularJson);
+    return analyzeTarget(libName, libPath, projectPath);
+}
+/**
+ * Analyse les artefacts Angular d'un target (app ou lib) - DRY
+ */
+function analyzeTarget(targetName, targetPath, projectPath) {
+    const { description, dependencies, devDependencies } = extractPackageDeps(projectPath);
     return {
-        name: appName,
+        name: targetName,
         description,
-        path: appPath,
+        path: targetPath,
         dependencies,
         devDependencies,
-        components,
-        modules,
-        services,
-        directives,
-        pipes,
-        guards,
-        interceptors,
-        resolvers
+        components: (0, core_1.countFiles)(targetPath, /\.component\.ts$/),
+        modules: (0, core_1.countFiles)(targetPath, /\.module\.ts$/),
+        services: (0, core_1.countFiles)(targetPath, /\.service\.ts$/),
+        directives: (0, core_1.countFiles)(targetPath, /\.directive\.ts$/),
+        pipes: (0, core_1.countFiles)(targetPath, /\.pipe\.ts$/),
+        guards: (0, core_1.countFiles)(targetPath, /\.guard\.ts$/),
+        interceptors: (0, core_1.countFiles)(targetPath, /\.interceptor\.ts$/),
+        resolvers: (0, core_1.countFiles)(targetPath, /\.resolver\.ts$/)
     };
 }
 /**
- * Analyse les détails d'une librairie Angular (Nx uniquement)
+ * Extrait les dépendances du package.json
  */
-function analyzeLib(libName, projectPath) {
-    const libPath = path.join(projectPath, 'libs', libName);
+function extractPackageDeps(projectPath) {
     const packageJsonPath = path.join(projectPath, 'package.json');
-    let description;
-    let dependencies = 0;
-    let devDependencies = 0;
-    if (fs.existsSync(packageJsonPath)) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return { dependencies: 0, devDependencies: 0 };
+    }
+    try {
         const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        description = packageJson.description;
-        dependencies = Object.keys(packageJson.dependencies || {}).length;
-        devDependencies = Object.keys(packageJson.devDependencies || {}).length;
+        return {
+            description: packageJson.description,
+            dependencies: Object.keys(packageJson.dependencies || {}).length,
+            devDependencies: Object.keys(packageJson.devDependencies || {}).length
+        };
     }
-    const components = (0, core_1.countFiles)(libPath, /\.component\.ts$/);
-    const modules = (0, core_1.countFiles)(libPath, /\.module\.ts$/);
-    const services = (0, core_1.countFiles)(libPath, /\.service\.ts$/);
-    const directives = (0, core_1.countFiles)(libPath, /\.directive\.ts$/);
-    const pipes = (0, core_1.countFiles)(libPath, /\.pipe\.ts$/);
-    const guards = (0, core_1.countFiles)(libPath, /\.guard\.ts$/);
-    const interceptors = (0, core_1.countFiles)(libPath, /\.interceptor\.ts$/);
-    const resolvers = (0, core_1.countFiles)(libPath, /\.resolver\.ts$/);
-    return {
-        name: libName,
-        description,
-        path: libPath,
-        dependencies,
-        devDependencies,
-        components,
-        modules,
-        services,
-        directives,
-        pipes,
-        guards,
-        interceptors,
-        resolvers
-    };
+    catch {
+        return { dependencies: 0, devDependencies: 0 };
+    }
+}
+/**
+ * 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 (ou src/ pour single-app)
+    if (isNxMonorepo) {
+        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];
+    if (projectConfig?.root) {
+        return path.join(projectPath, projectConfig.root);
+    }
+    if (projectConfig?.sourceRoot) {
+        return path.join(projectPath, projectConfig.sourceRoot);
+    }
+    // Fallback : convention projects/xxx ou src/ pour standalone
+    return nxFolder === 'apps' && !angularJson?.projects
+        ? path.join(projectPath, 'src')
+        : path.join(projectPath, 'projects', targetName);
 }

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

@@ -41,14 +41,39 @@ function matchesElementPattern(node, pattern, htmlContent) {
 }
 /**
  * Matche un pattern DeferredBlock (@defer blocks)
+ * Supporte deferTrigger pour filtrer par type de trigger et options
  */
-function matchesDeferredBlockPattern(node, htmlContent) {
+function matchesDeferredBlockPattern(node, pattern, htmlContent) {
     // Vérifier si c'est un DeferredBlock
-    if (node.constructor && node.constructor.name === 'DeferredBlock') {
-        return {
-            lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
-            matchedText: (0, html_parser_1.getNodeText)(node, htmlContent).substring(0, 100)
-        };
+    if (!node.constructor || node.constructor.name !== 'DeferredBlock') {
+        return null;
     }
-    return null;
+    // Si deferTrigger est spécifié, vérifier les triggers
+    if (pattern.deferTrigger) {
+        const triggerType = pattern.deferTrigger.type;
+        const triggers = node.triggers || {};
+        const trigger = triggers[triggerType];
+        // Le trigger doit exister
+        if (!trigger) {
+            return null;
+        }
+        // Vérifier hasOptions (le trigger a des options si reference est non vide)
+        if (pattern.deferTrigger.hasOptions !== undefined) {
+            const hasOptions = trigger.reference && trigger.reference.trim().length > 0;
+            if (pattern.deferTrigger.hasOptions !== hasOptions) {
+                return null;
+            }
+        }
+        // Vérifier optionsMatch (regex sur reference)
+        if (pattern.deferTrigger.optionsMatch && trigger.reference) {
+            const regex = new RegExp(pattern.deferTrigger.optionsMatch);
+            if (!regex.test(trigger.reference)) {
+                return null;
+            }
+        }
+    }
+    return {
+        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent).substring(0, 100)
+    };
 }

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

@@ -11,15 +11,15 @@ const html_text_matcher_1 = require("./html-text-matcher");
 const html_pipe_matcher_1 = require("./html-pipe-matcher");
 /**
  * Vérifie si un nœud HTML correspond à un pattern AST HTML
- * Supporte : Attribute, PipeExpression, BoundText, Element, DeferredBlock
+ * Supporte : Attribute, BoundAttribute, PipeExpression, BoundText, Element, DeferredBlock
  */
 function matchesHtmlNode(node, pattern, htmlContent) {
     // Pattern: BoundText (interpolations {{ ... }})
     if (pattern.nodeType === 'BoundText') {
         return (0, html_text_matcher_1.matchesBoundTextPattern)(node, pattern, htmlContent);
     }
-    // Pattern: Attribute (*ngIf, *ngFor, etc.)
-    if (pattern.nodeType === 'Attribute' && (0, html_parser_1.isElement)(node)) {
+    // Pattern: Attribute (*ngIf, *ngFor, etc.) ou BoundAttribute ([ngClass], [ngStyle], etc.)
+    if ((pattern.nodeType === 'Attribute' || pattern.nodeType === 'BoundAttribute') && (0, html_parser_1.isElement)(node)) {
         return (0, html_attribute_matcher_1.matchesAttributePattern)(node, pattern, htmlContent);
     }
     // Pattern: Element (ng-content, div, etc.)
@@ -28,7 +28,7 @@ function matchesHtmlNode(node, pattern, htmlContent) {
     }
     // Pattern: DeferredBlock (@defer blocks)
     if (pattern.nodeType === 'DeferredBlock') {
-        return (0, html_element_matcher_1.matchesDeferredBlockPattern)(node, htmlContent);
+        return (0, html_element_matcher_1.matchesDeferredBlockPattern)(node, pattern, htmlContent);
     }
     // Pattern: PipeExpression (| async, | date, etc.)
     if (pattern.nodeType === 'PipeExpression' && pattern.pipeName) {
@@ -57,6 +57,26 @@ function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
                 (0, html_pipe_matcher_1.traversePipeExpression)(value, pattern, htmlContent, matches);
             }
         }
+        // Si pattern cherche PipeExpression et node est Element, parcourir les valeurs d'attributs (pour *ngFor avec | pipe)
+        if (pattern.nodeType === 'PipeExpression' && (0, html_parser_1.isElement)(node)) {
+            const element = node;
+            // Parcourir inputs (property bindings) et templateAttrs (*ngFor, *ngIf, etc.)
+            const allBoundAttrs = [
+                ...element.inputs,
+                ...(element.templateAttrs || [])
+            ];
+            for (const attr of allBoundAttrs) {
+                if ('value' in attr && attr.value) {
+                    const attrValue = attr.value;
+                    if (attrValue.ast) {
+                        (0, html_pipe_matcher_1.traversePipeExpression)(attrValue.ast, pattern, htmlContent, matches);
+                    }
+                    else {
+                        (0, html_pipe_matcher_1.traversePipeExpression)(attrValue, pattern, htmlContent, matches);
+                    }
+                }
+            }
+        }
         // 1. Parcourir les enfants standards
         if ('children' in node && Array.isArray(node.children)) {
             traverseHtmlAst(node.children, pattern, htmlContent, matches);
@@ -81,6 +101,17 @@ function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
         if ('empty' in node && node.empty?.children) {
             traverseHtmlAst(node.empty.children, pattern, htmlContent, matches);
         }
+        // 4b. Parcourir @for expression (for PipeExpression like | keyvalue)
+        if (pattern.nodeType === 'PipeExpression' && 'expression' in node && node.expression) {
+            const forExpression = node.expression;
+            // expression est ASTWithSource, l'AST réel est dans expression.ast
+            if (forExpression.ast) {
+                (0, html_pipe_matcher_1.traversePipeExpression)(forExpression.ast, pattern, htmlContent, matches);
+            }
+            else {
+                (0, html_pipe_matcher_1.traversePipeExpression)(forExpression, pattern, htmlContent, matches);
+            }
+        }
         // 5-8. Parcourir @defer sub-blocks (mainBlock, placeholder, loading, error)
         const deferSubBlocks = ['mainBlock', 'placeholder', 'loading', 'error'];
         for (const blockName of deferSubBlocks) {
@@ -110,6 +141,7 @@ function findHtmlPatternMatches(htmlContent, pattern) {
  */
 function isHtmlPattern(pattern) {
     return pattern.nodeType === 'Attribute' ||
+        pattern.nodeType === 'BoundAttribute' ||
         pattern.nodeType === 'PipeExpression' ||
         pattern.nodeType === 'BoundText' ||
         pattern.nodeType === 'Element' ||

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

@@ -16,6 +16,24 @@ function matchesElements(node, elementsPattern, matchesAstPatternFn) {
     if (typeof elementsPattern === 'object' && elementsPattern.notEmpty === true) {
         return elements.length > 0;
     }
+    // Vérifier missing (l'élément nommé NE doit PAS être présent dans le tableau)
+    if (typeof elementsPattern === 'object' && elementsPattern.missing) {
+        const missingName = elementsPattern.missing;
+        const hasElement = elements.some(element => {
+            // CallExpression: provideZoneChangeDetection()
+            if (ts_morph_1.Node.isCallExpression(element)) {
+                const funcName = element.getExpression().getText().split('.').pop() || '';
+                return funcName === missingName;
+            }
+            // Identifier: someProvider
+            if (ts_morph_1.Node.isIdentifier(element)) {
+                return element.getText() === missingName;
+            }
+            return false;
+        });
+        // Le pattern matche si l'élément est ABSENT
+        return !hasElement;
+    }
     // Vérifier contains (au moins un élément matche le pattern)
     if (elementsPattern.contains) {
         return elements.some(element => matchesAstPatternFn(element, elementsPattern.contains));

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

@@ -172,7 +172,7 @@ function checkObjectProperties(objectNode, properties, matchesAstPatternFn) {
                 return false;
             }
         }
-        // Vérifier elements avec referTo (cas spécial pour résolution de symboles)
+        // Vérifier elements avec referTo ou missing (cas spéciaux pour résolution de symboles ou vérification d'absence)
         if (typeof propPattern === 'object' && 'elements' in propPattern && 'exists' in propPattern) {
             // Ce pattern a à la fois exists (pour vérifier que la propriété existe)
             // ET elements (pour vérifier le contenu du tableau)
@@ -180,8 +180,6 @@ function checkObjectProperties(objectNode, properties, matchesAstPatternFn) {
             if (!initializer) {
                 return false;
             }
-            // IMPORTANT : Si elements.referTo existe, on doit construire un pattern AST complet
-            // avec nodeType: ArrayLiteralExpression pour que matchesAstPattern le reconnaisse
             const elementsPattern = propPattern.elements;
             // Si referTo est présent, créer un pattern AST complet
             if (typeof elementsPattern === 'object' && 'referTo' in elementsPattern) {
@@ -194,8 +192,19 @@ function checkObjectProperties(objectNode, properties, matchesAstPatternFn) {
                     return false;
                 }
             }
+            else if (typeof elementsPattern === 'object' && 'missing' in elementsPattern) {
+                // Cas spécial: vérifier que l'élément nommé est ABSENT du tableau
+                // Créer un pattern AST complet pour ArrayLiteralExpression avec elements.missing
+                const fullPattern = {
+                    nodeType: 'ArrayLiteralExpression',
+                    elements: elementsPattern
+                };
+                if (matchesAstPatternFn && !matchesAstPatternFn(initializer, fullPattern)) {
+                    return false;
+                }
+            }
             else {
-                // Pattern normal sans referTo
+                // Pattern normal
                 if (matchesAstPatternFn && !matchesAstPatternFn(initializer, elementsPattern)) {
                     return false;
                 }
@@ -361,6 +370,26 @@ function matchesParameters(node, parametersPattern) {
             return false;
         }
     }
+    // Vérifier first.type (type du premier paramètre - sans générique)
+    if (parametersPattern.first?.type) {
+        const firstParam = parameters[0];
+        if (!firstParam) {
+            return false;
+        }
+        const typeNode = firstParam.getTypeNode();
+        if (!typeNode) {
+            return false;
+        }
+        // Obtenir le texte du type
+        const typeText = typeNode.getText();
+        // Vérifier que le type correspond EXACTEMENT (sans générique)
+        // Ex: "SimpleChanges" doit matcher, mais pas "SimpleChanges<UserComponent>"
+        const expectedType = parametersPattern.first.type;
+        // Le type doit être exactement le type attendu (pas un générique)
+        if (typeText !== expectedType) {
+            return false;
+        }
+    }
     return true;
 }
 /**

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

@@ -111,7 +111,7 @@ function matchesArguments(node, argumentsPattern, matchesAstPatternFn) {
         // Chercher dans tous les arguments pour trouver un ObjectLiteralExpression
         for (const arg of args) {
             if (ts_morph_1.Node.isObjectLiteralExpression(arg)) {
-                const result = (0, decorator_matcher_1.checkObjectProperties)(arg, argumentsPattern.properties);
+                const result = (0, decorator_matcher_1.checkObjectProperties)(arg, argumentsPattern.properties, matchesAstPatternFn);
                 // Si on trouve un objet qui matche (ou qui ne matche pas les missing), on retourne le résultat
                 if (result || Object.values(argumentsPattern.properties).some((p) => p && typeof p === 'object' && p.missing)) {
                     return result;

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

@@ -53,6 +53,10 @@ function matchesName(node, name) {
     if (ts_morph_1.Node.isVariableDeclaration(node)) {
         return names.includes(node.getName());
     }
+    // Pour PropertyDeclaration (ex: content: any[][] = [])
+    if (ts_morph_1.Node.isPropertyDeclaration(node)) {
+        return names.includes(node.getName());
+    }
     return false;
 }
 /**