@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,465 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTemplateCache = clearTemplateCache;
+exports.checkObjectProperties = checkObjectProperties;
+exports.matchesProperties = matchesProperties;
+exports.matchesTemplate = matchesTemplate;
+exports.matchesParameters = matchesParameters;
+exports.matchesDeclarations = matchesDeclarations;
+exports.matchesPipeName = matchesPipeName;
+exports.matchesOptionalChaining = matchesOptionalChaining;
+exports.matchesNonNullAssertion = matchesNonNullAssertion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const matcher_helpers_1 = require("../utils/matcher-helpers");
+/**
+ * Cache LRU pour les fichiers HTML externes (templateUrl)
+ * Clé: chemin absolu du fichier HTML
+ * Valeur: contenu du fichier
+ * Taille max: 100 fichiers (évite surcharge mémoire)
+ */
+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 appels)
+const templateCache = new TemplateCache();
+/**
+ * Efface le cache des templates (pour tests ou libération mémoire)
+ */
+function clearTemplateCache() {
+    templateCache.clear();
+}
+/**
+ * Vérifie les propriétés d'un objet littéral
+ * @param objectNode Nœud ObjectLiteralExpression
+ * @param properties Patterns de propriétés à vérifier
+ * @param matchesAstPatternFn Fonction de matching récursif (optionnelle)
+ */
+function checkObjectProperties(objectNode, properties, matchesAstPatternFn) {
+    for (const [propName, propPattern] of Object.entries(properties)) {
+        const property = objectNode.getProperty(propName);
+        // Vérifier si la propriété doit exister
+        // SAUF si le pattern a aussi 'elements' (traité plus tard pour valider le contenu)
+        if (typeof propPattern === 'object' && 'exists' in propPattern && !('elements' in propPattern)) {
+            const shouldExist = propPattern.exists;
+            const exists = property !== undefined;
+            if (shouldExist !== exists) {
+                return false;
+            }
+        }
+        // Vérifier si la propriété doit être manquante
+        if (typeof propPattern === 'object' && 'missing' in propPattern) {
+            const shouldBeMissing = propPattern.missing;
+            const exists = property !== undefined;
+            if (shouldBeMissing && exists) {
+                return false;
+            }
+        }
+        // Vérifier containsAny
+        if (typeof propPattern === 'object' && 'containsAny' in propPattern) {
+            const initializer = getPropertyInitializer(property);
+            if (!initializer) {
+                return false;
+            }
+            // Si l'initializer est un objet et que containsAny a des patterns avec valueMatches + nodeType: StringLiteral
+            // alors vérifier les noms de propriétés de l'objet (cas onpush_host_bindings)
+            const hasValueMatchesPattern = propPattern.containsAny.some((p) => typeof p === 'object' && 'valueMatches' in p && p.nodeType === 'StringLiteral');
+            if (hasValueMatchesPattern && ts_morph_1.Node.isObjectLiteralExpression(initializer)) {
+                // Cas spécial: vérifier les noms de propriétés de l'objet avec valueMatches
+                const propertyNames = initializer.getProperties().map(p => {
+                    if (ts_morph_1.Node.isPropertyAssignment(p)) {
+                        return p.getName();
+                    }
+                    return '';
+                });
+                const hasMatch = propPattern.containsAny.some((subPattern) => {
+                    if (typeof subPattern === 'object' && subPattern.valueMatches) {
+                        const regex = new RegExp(subPattern.valueMatches);
+                        return propertyNames.some(name => regex.test(name));
+                    }
+                    return false;
+                });
+                if (!hasMatch) {
+                    return false;
+                }
+            }
+            else {
+                // Vérification classique: matcher sur l'initializer avec matchesAstPatternFn
+                if (matchesAstPatternFn) {
+                    const hasMatch = propPattern.containsAny.some((subPattern) => matchesAstPatternFn(initializer, subPattern));
+                    if (!hasMatch) {
+                        return false;
+                    }
+                }
+            }
+        }
+        // Vérifier les valeurs spécifiques des propriétés (string, boolean, etc.)
+        if (typeof propPattern === 'string') {
+            const initializer = getPropertyInitializer(property);
+            if (!initializer) {
+                return false;
+            }
+            const valueText = initializer.getText();
+            // Normaliser les valeurs (retirer quotes, etc.)
+            const normalizedValue = valueText.replace(/['"]/g, '');
+            if (normalizedValue !== propPattern && valueText !== propPattern) {
+                return false;
+            }
+        }
+        // Vérification générique pour les patterns AST complexes (avec nodeType, elements, etc.)
+        if (typeof propPattern === 'object' &&
+            !('exists' in propPattern) &&
+            !('missing' in propPattern) &&
+            !('containsAny' in propPattern) &&
+            matchesAstPatternFn) {
+            const initializer = getPropertyInitializer(property);
+            if (!initializer) {
+                return false;
+            }
+            // Appliquer le matcher récursif sur l'initializer
+            if (!matchesAstPatternFn(initializer, propPattern)) {
+                return false;
+            }
+        }
+        // Vérifier elements avec referTo (cas spécial pour résolution de symboles)
+        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)
+            const initializer = getPropertyInitializer(property);
+            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) {
+                // Créer un pattern AST complet pour ArrayLiteralExpression
+                const fullPattern = {
+                    nodeType: 'ArrayLiteralExpression',
+                    elements: elementsPattern
+                };
+                if (matchesAstPatternFn && !matchesAstPatternFn(initializer, fullPattern)) {
+                    return false;
+                }
+            }
+            else {
+                // Pattern normal sans referTo
+                if (matchesAstPatternFn && !matchesAstPatternFn(initializer, elementsPattern)) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Vérifie les propriétés d'un décorateur ou objet littéral
+ */
+function matchesProperties(node, properties, matchesAstPatternFn) {
+    // Pour les décorateurs @Component, @Directive, etc.
+    if (ts_morph_1.Node.isDecorator(node)) {
+        const expression = node.getExpression();
+        if (!ts_morph_1.Node.isCallExpression(expression)) {
+            return false;
+        }
+        const args = expression.getArguments();
+        if (args.length === 0) {
+            return false;
+        }
+        const configObject = args[0];
+        if (!ts_morph_1.Node.isObjectLiteralExpression(configObject)) {
+            return false;
+        }
+        return checkObjectProperties(configObject, properties, matchesAstPatternFn);
+    }
+    // Pour les ObjectLiteralExpression
+    if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+        return checkObjectProperties(node, properties, matchesAstPatternFn);
+    }
+    return false;
+}
+/**
+ * Extrait le contenu du template d'un @Component (inline ou externe via templateUrl)
+ * @returns Le contenu du template ou null si introuvable
+ */
+function getTemplateContent(node) {
+    if (!ts_morph_1.Node.isDecorator(node)) {
+        return null;
+    }
+    const expression = node.getExpression();
+    if (!ts_morph_1.Node.isCallExpression(expression)) {
+        return null;
+    }
+    const args = expression.getArguments();
+    if (args.length === 0) {
+        return null;
+    }
+    const configObject = args[0];
+    if (!ts_morph_1.Node.isObjectLiteralExpression(configObject)) {
+        return null;
+    }
+    // Cas 1: Template inline (propriété 'template')
+    const templateProperty = configObject.getProperty('template');
+    if (templateProperty && ts_morph_1.Node.isPropertyAssignment(templateProperty)) {
+        const templateValue = templateProperty.getInitializer();
+        if (templateValue) {
+            return templateValue.getText().replace(/[`'"]/g, '');
+        }
+    }
+    // Cas 2: Template externe (propriété 'templateUrl')
+    const templateUrlProperty = configObject.getProperty('templateUrl');
+    if (templateUrlProperty && ts_morph_1.Node.isPropertyAssignment(templateUrlProperty)) {
+        const templateUrlValue = templateUrlProperty.getInitializer();
+        if (!templateUrlValue) {
+            return null;
+        }
+        // Extraire le chemin du templateUrl (retirer quotes)
+        const templateUrl = templateUrlValue.getText().replace(/[`'"]/g, '');
+        // Résoudre le chemin relatif au fichier TS
+        const sourceFile = node.getSourceFile();
+        const tsFilePath = sourceFile.getFilePath();
+        const tsDir = path.dirname(tsFilePath);
+        const htmlFilePath = path.resolve(tsDir, templateUrl);
+        // Vérifier le cache d'abord
+        const cached = templateCache.get(htmlFilePath);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Lire le fichier HTML
+        try {
+            if (fs.existsSync(htmlFilePath)) {
+                const content = fs.readFileSync(htmlFilePath, 'utf-8');
+                templateCache.set(htmlFilePath, content);
+                return content;
+            }
+        }
+        catch (error) {
+            // Fichier introuvable ou erreur de lecture : skip silencieusement
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Vérifie le template d'un composant Angular (inline ou externe)
+ * Support des templateUrl (fichiers HTML séparés) avec cache LRU
+ */
+function matchesTemplate(node, templatePattern) {
+    const templateText = getTemplateContent(node);
+    if (!templateText) {
+        return false;
+    }
+    // Nettoyer les commentaires HTML avant de vérifier les patterns
+    let cleanedTemplate = templateText.replace(/<!--[\s\S]*?-->/g, '');
+    // Pour "router-outlet", chercher la balise HTML, pas juste la substring
+    // Convertir "router-outlet" → regex qui matche "<router-outlet" (balise ouvrante ou autofermante)
+    if (templatePattern.contains) {
+        const searchTerm = templatePattern.contains;
+        // Si c'est un nom de balise HTML (lettres, chiffres, tirets uniquement), créer une regex pour matcher la balise
+        // Sinon, faire une recherche littérale de substring
+        const isHtmlTag = /^[a-zA-Z][\w-]*$/.test(searchTerm);
+        if (isHtmlTag) {
+            // Chercher <tag ou <tag> ou <tag/> ou <tag
+            const tagRegex = new RegExp(`<${searchTerm}(?:\\s|>|/|$)`, 'i');
+            if (!tagRegex.test(cleanedTemplate)) {
+                return false;
+            }
+        }
+        else {
+            // Recherche littérale (pour des patterns comme "| async", "<div>", etc.)
+            if (!cleanedTemplate.includes(searchTerm)) {
+                return false;
+            }
+        }
+    }
+    if (templatePattern.notContains) {
+        // Pour notContains, toujours chercher la substring
+        // (car on veut détecter "routerOutletData" dans [routerOutletData]="...")
+        if (cleanedTemplate.includes(templatePattern.notContains)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Vérifie les paramètres d'un constructeur ou d'une fonction
+ */
+function matchesParameters(node, parametersPattern) {
+    let parameters = [];
+    if (ts_morph_1.Node.isFunctionDeclaration(node) || ts_morph_1.Node.isMethodDeclaration(node) || ts_morph_1.Node.isConstructorDeclaration(node)) {
+        parameters = node.getParameters();
+    }
+    if (parameters.length === 0) {
+        return false;
+    }
+    // Vérifier hasModifier
+    if (parametersPattern.hasModifier) {
+        const hasModifier = parameters.some(param => {
+            const modifiers = param.getModifiers().map((m) => m.getText());
+            return parametersPattern.hasModifier.some((mod) => modifiers.includes(mod));
+        });
+        if (!hasModifier) {
+            return false;
+        }
+    }
+    // Vérifier hasType
+    if (parametersPattern.hasType !== undefined) {
+        const hasType = parameters.some(param => param.getTypeNode() !== undefined);
+        if (hasType !== parametersPattern.hasType) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Vérifie les déclarations (pour VariableStatement)
+ */
+function matchesDeclarations(node, declarationsPattern, matchesAstPatternFn) {
+    if (!ts_morph_1.Node.isVariableStatement(node)) {
+        return false;
+    }
+    const declarations = node.getDeclarationList().getDeclarations();
+    // Vérifier name
+    if (declarationsPattern.name) {
+        const names = (0, matcher_helpers_1.ensureArray)(declarationsPattern.name);
+        const hasMatch = declarations.some(decl => {
+            const declName = decl.getName();
+            return names.includes(declName);
+        });
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    // Vérifier initializer avec matchesAstPatternFn
+    if (declarationsPattern.initializer && matchesAstPatternFn) {
+        const hasMatch = declarations.some(decl => {
+            const initializer = decl.getInitializer();
+            if (!initializer) {
+                return false;
+            }
+            return matchesAstPatternFn(initializer, declarationsPattern.initializer);
+        });
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Vérifie le nom d'une pipe dans un template
+ */
+function matchesPipeName(node, pipeName) {
+    // Cette fonction nécessiterait l'analyse du template HTML
+    // Pour l'instant, retourne false car elle nécessite @angular/compiler
+    return false;
+}
+/**
+ * Vérifie si le nœud utilise optional chaining
+ * Note: si shouldHaveOptionalChaining est true, on accepte TOUT nœud qui a ?.
+ * Cela inclut les PropertyAccessExpression avec ?. OU leurs parents NonNullExpression
+ */
+function matchesOptionalChaining(node, shouldHaveOptionalChaining) {
+    // Vérifier si c'est une PropertyAccessExpression avec ?.
+    if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        const hasOptionalChaining = node.getQuestionDotTokenNode() !== undefined;
+        if (hasOptionalChaining) {
+            return shouldHaveOptionalChaining;
+        }
+    }
+    // Vérifier si c'est l'expression interne d'une NonNullExpression qui contient ?.
+    if (ts_morph_1.Node.isNonNullExpression(node)) {
+        const expr = node.getExpression();
+        if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+            const hasOptionalChaining = expr.getQuestionDotTokenNode() !== undefined;
+            if (hasOptionalChaining) {
+                return shouldHaveOptionalChaining;
+            }
+        }
+    }
+    // Si shouldHaveOptionalChaining est false, accepter les nœuds sans ?.
+    return !shouldHaveOptionalChaining;
+}
+/**
+ * Vérifie si le nœud utilise non-null assertion
+ * Note: si shouldHaveNonNullAssertion est true, on accepte TOUT nœud qui a !
+ * Cela inclut les NonNullExpression OU les PropertyAccessExpression qui sont dans une NonNullExpression
+ */
+function matchesNonNullAssertion(node, shouldHaveNonNullAssertion) {
+    // Cas 1: Le nœud est une NonNullExpression (ex: control!)
+    if (ts_morph_1.Node.isNonNullExpression(node)) {
+        return shouldHaveNonNullAssertion;
+    }
+    // Cas 2: Le nœud est l'expression interne d'une NonNullExpression (ex: dans control.valueChanges!)
+    const parent = node.getParent();
+    if (parent && ts_morph_1.Node.isNonNullExpression(parent)) {
+        return shouldHaveNonNullAssertion;
+    }
+    // Cas 3: Pas de non-null assertion
+    return !shouldHaveNonNullAssertion;
+}
+/**
+ * Helper: Extrait l'initializer d'une propriété
+ * Retourne null si la propriété n'existe pas, n'est pas une PropertyAssignment, ou n'a pas d'initializer
+ */
+function getPropertyInitializer(property) {
+    if (!property) {
+        return null;
+    }
+    if (!ts_morph_1.Node.isPropertyAssignment(property)) {
+        return null;
+    }
+    const initializer = property.getInitializer();
+    return initializer || null;
+}