@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesNodeType = matchesNodeType;
+exports.matchesName = matchesName;
+exports.matchesPropertyName = matchesPropertyName;
+exports.matchesFunctionName = matchesFunctionName;
+exports.matchesValue = matchesValue;
+exports.matchesOperatorKind = matchesOperatorKind;
+exports.matchesModifiers = matchesModifiers;
+exports.matchesExported = matchesExported;
+exports.matchesValuePattern = matchesValuePattern;
+exports.matchesText = matchesText;
+const ts_morph_1 = require("ts-morph");
+const matcher_helpers_1 = require("../utils/matcher-helpers");
+/**
+ * Vérifie si le nœud correspond au type demandé
+ */
+function matchesNodeType(node, nodeType) {
+    const nodeTypes = (0, matcher_helpers_1.ensureArray)(nodeType);
+    const nodeKindName = node.getKindName();
+    return nodeTypes.includes(nodeKindName);
+}
+/**
+ * Vérifie le nom du nœud (Identifier, Decorator, PropertyAccessExpression, PropertyAssignment, MethodDeclaration, etc.)
+ */
+function matchesName(node, name) {
+    const names = (0, matcher_helpers_1.ensureArray)(name);
+    if (ts_morph_1.Node.isIdentifier(node)) {
+        return names.includes(node.getText());
+    }
+    if (ts_morph_1.Node.isDecorator(node)) {
+        const expression = node.getExpression();
+        if (ts_morph_1.Node.isCallExpression(expression)) {
+            const decoratorName = expression.getExpression().getText();
+            return names.includes(decoratorName);
+        }
+        return names.includes(expression.getText());
+    }
+    // Pour PropertyAccessExpression, vérifier le nom de la propriété
+    // Cela permet d'utiliser "name" comme alias de "propertyName"
+    if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        return names.includes(node.getName());
+    }
+    // Pour PropertyAssignment (ex: { redirectTo: '/home' })
+    if (ts_morph_1.Node.isPropertyAssignment(node)) {
+        return names.includes(node.getName());
+    }
+    // Pour MethodDeclaration (ex: canActivate() { })
+    if (ts_morph_1.Node.isMethodDeclaration(node)) {
+        return names.includes(node.getName());
+    }
+    // Pour VariableDeclaration (ex: const serverRoutes: ServerRoute[] = [])
+    if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        return names.includes(node.getName());
+    }
+    return false;
+}
+/**
+ * Vérifie le nom de propriété (PropertyAccessExpression)
+ */
+function matchesPropertyName(node, propertyName) {
+    const propertyNames = (0, matcher_helpers_1.ensureArray)(propertyName);
+    if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        const propName = node.getName();
+        return propertyNames.includes(propName);
+    }
+    return false;
+}
+/**
+ * Vérifie le nom de fonction (CallExpression)
+ */
+function matchesFunctionName(node, functionName) {
+    const functionNames = (0, matcher_helpers_1.ensureArray)(functionName);
+    if (ts_morph_1.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        const funcName = expression.getText().split('.').pop() || '';
+        return functionNames.includes(funcName);
+    }
+    return false;
+}
+/**
+ * Vérifie la valeur d'un nœud
+ */
+function matchesValue(node, value) {
+    const nodeText = node.getText();
+    const expectedValue = (0, matcher_helpers_1.normalizeValue)(value);
+    return (0, matcher_helpers_1.matchesTextValue)(nodeText, expectedValue);
+}
+/**
+ * Vérifie le type d'opérateur (BinaryExpression)
+ */
+function matchesOperatorKind(node, operatorKind) {
+    if (!ts_morph_1.Node.isBinaryExpression(node)) {
+        return false;
+    }
+    const operator = node.getOperatorToken();
+    return operator.getKindName() === operatorKind;
+}
+/**
+ * Vérifie les modificateurs (export, public, private, etc.)
+ */
+function matchesModifiers(node, modifiers) {
+    if (!('getModifiers' in node) || typeof node.getModifiers !== 'function') {
+        return false;
+    }
+    const nodeModifiers = node.getModifiers().map((m) => m.getText());
+    return modifiers.every(mod => nodeModifiers.includes(mod));
+}
+/**
+ * Vérifie si le nœud est exporté
+ */
+function matchesExported(node, shouldBeExported) {
+    // Pour VariableDeclaration, vérifier si le parent VariableStatement est exporté
+    if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        const parent = node.getParent();
+        if (parent && ts_morph_1.Node.isVariableDeclarationList(parent)) {
+            const grandParent = parent.getParent();
+            if (grandParent && ts_morph_1.Node.isVariableStatement(grandParent)) {
+                const isExported = grandParent.isExported();
+                return isExported === shouldBeExported;
+            }
+        }
+        return false;
+    }
+    if (!('isExported' in node) || typeof node.isExported !== 'function') {
+        return false;
+    }
+    const isExported = node.isExported();
+    return isExported === shouldBeExported;
+}
+/**
+ * Vérifie un pattern de valeur avec regex
+ */
+function matchesValuePattern(node, valuePattern) {
+    const nodeText = node.getText();
+    const regex = new RegExp(valuePattern);
+    return regex.test(nodeText);
+}
+/**
+ * Vérifie le texte d'un StringLiteral
+ */
+function matchesText(node, textPattern) {
+    if (!ts_morph_1.Node.isStringLiteral(node)) {
+        return false;
+    }
+    const text = node.getLiteralValue();
+    // Si c'est une string simple, vérifier l'égalité exacte
+    if (typeof textPattern === 'string') {
+        return text === textPattern;
+    }
+    // Si c'est un objet avec startsWith
+    if (textPattern.startsWith) {
+        return text.startsWith(textPattern.startsWith);
+    }
+    return true;
+}

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModuleSourceFile = resolveModuleSourceFile;
+exports.matchesReferTo = matchesReferTo;
+const ts_morph_1 = require("ts-morph");
+const ast_helpers_1 = require("../../../../utils/core/ast-helpers");
+/**
+ * Matcher pour la résolution de symboles cross-file (referTo)
+ * Utilise ts-morph getDefinitionNodes() pour suivre les références
+ */
+/**
+ * Profondeur maximale pour suivre les références cross-file
+ * (ImportSpecifier → ExportSpecifier → ... → ClassDeclaration)
+ *
+ * Valeur recommandée: 10+ pour projets Nx complexes avec barrel exports multiples
+ * Exemple: libs/feature/index.ts → libs/feature/services/index.ts → service.ts
+ */
+const MAX_REFERENCE_DEPTH = 20;
+/**
+ * Résout un module specifier (chemin relatif ou absolu) vers un SourceFile
+ * Gère les chemins relatifs profonds que ts-morph en mémoire a du mal à résoudre
+ * @param moduleSpecifier - Chemin du module (ex: '../../../../libs/shared/services/user.service')
+ * @param fromFile - Fichier source qui fait l'import
+ * @returns SourceFile résolu ou undefined
+ */
+function resolveModuleSourceFile(moduleSpecifier, fromFile) {
+    const project = fromFile.getProject();
+    // APPROCHE 1: Essayer getModuleSpecifierSourceFile (fonctionne pour chemins simples)
+    const directResolve = fromFile.getImportDeclarations()
+        .find(imp => imp.getModuleSpecifierValue() === moduleSpecifier)
+        ?.getModuleSpecifierSourceFile();
+    if (directResolve) {
+        return directResolve;
+    }
+    // APPROCHE 2: Résolution manuelle pour chemins relatifs (en mémoire)
+    if (moduleSpecifier.startsWith('.')) {
+        const fromPath = fromFile.getFilePath();
+        const parts = fromPath.split('/').filter(p => p);
+        // Retirer le fichier pour avoir le directory
+        parts.pop();
+        // Parser le module specifier
+        const moduleParts = moduleSpecifier.split('/');
+        // Naviguer selon les ../ et ./
+        for (const part of moduleParts) {
+            if (part === '..') {
+                parts.pop();
+            }
+            else if (part !== '.') {
+                parts.push(part);
+            }
+        }
+        // Reconstruire le chemin
+        const resolvedPath = '/' + parts.join('/');
+        // Essayer avec différentes extensions
+        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx'];
+        for (const ext of extensions) {
+            const pathWithExt = resolvedPath + ext;
+            const sourceFile = project.getSourceFile(pathWithExt);
+            if (sourceFile) {
+                return sourceFile;
+            }
+        }
+        // Dernière tentative: chercher par nom de fichier relatif
+        const allFiles = project.getSourceFiles();
+        const fileName = parts[parts.length - 1];
+        for (const file of allFiles) {
+            const filePath = file.getFilePath();
+            if (filePath.endsWith('/' + fileName + '.ts') ||
+                filePath.endsWith('/' + fileName + '.tsx') ||
+                filePath.endsWith('/' + fileName + '/index.ts')) {
+                // Vérifier que le chemin complet correspond
+                const filePathParts = filePath.split('/').filter(p => p);
+                let match = true;
+                for (let i = 0; i < parts.length && i < filePathParts.length; i++) {
+                    if (parts[parts.length - 1 - i] !== filePathParts[filePathParts.length - 1 - i]) {
+                        match = false;
+                        break;
+                    }
+                }
+                if (match) {
+                    return file;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Résout récursivement un ImportSpecifier/ExportSpecifier vers sa déclaration finale
+ * Suit la chaîne: ImportSpecifier → ExportSpecifier → ... → ClassDeclaration
+ *
+ * @param node - Nœud de départ (ImportSpecifier ou ExportSpecifier)
+ * @param maxDepth - Profondeur maximale de récursion
+ * @returns Nœud final résolu ou le nœud d'origine si résolution impossible
+ */
+function resolveSpecifierRecursively(node, maxDepth = MAX_REFERENCE_DEPTH) {
+    let targetNode = node;
+    let depth = 0;
+    while ((0, ast_helpers_1.isImportOrExportSpecifier)(targetNode) && depth < maxDepth) {
+        const nextNode = resolveSpecifierOneLevel(targetNode);
+        if (!nextNode)
+            break;
+        targetNode = nextNode;
+        depth++;
+    }
+    return targetNode;
+}
+/**
+ * Résout un ImportSpecifier/ExportSpecifier d'un niveau
+ * Essaie via getSymbol() d'abord, puis via navigation manuelle du module
+ *
+ * @param specifier - ImportSpecifier ou ExportSpecifier
+ * @returns Prochain nœud dans la chaîne ou undefined
+ */
+function resolveSpecifierOneLevel(specifier) {
+    // APPROCHE 1: Via getSymbol() + getAliasedSymbol()
+    const symbol = specifier.getSymbol();
+    if (symbol) {
+        const aliasedSymbol = symbol.getAliasedSymbol() || symbol;
+        const declarations = aliasedSymbol.getDeclarations();
+        if (declarations.length > 0) {
+            return declarations[0];
+        }
+    }
+    // APPROCHE 2: Via navigation manuelle du module (barrel exports en mémoire)
+    const parentDecl = (0, ast_helpers_1.findImportOrExportDeclaration)(specifier);
+    if (!parentDecl)
+        return undefined;
+    const moduleInfo = (0, ast_helpers_1.extractModuleInfo)(parentDecl, specifier);
+    if (!moduleInfo)
+        return undefined;
+    const resolvedFile = resolveModuleSourceFile(moduleInfo.moduleSpecifier, moduleInfo.sourceFile);
+    if (!resolvedFile)
+        return undefined;
+    const exports = resolvedFile.getExportedDeclarations();
+    const exportedNodes = exports.get(moduleInfo.name);
+    return exportedNodes && exportedNodes.length > 0 ? exportedNodes[0] : undefined;
+}
+/**
+ * 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.)
+ * @returns true si le symbole référencé matche le pattern
+ */
+function matchesReferTo(node, referToPattern) {
+    const identifierNode = extractIdentifierNode(node, referToPattern);
+    if (!identifierNode || !ts_morph_1.Node.isIdentifier(identifierNode))
+        return false;
+    const definitions = identifierNode.getDefinitionNodes();
+    if (definitions.length === 0)
+        return false;
+    return definitions.some((def) => matchesDefinition(def, referToPattern));
+}
+/**
+ * Extrait le nœud Identifier du nœud donné selon le pattern
+ * @param node - Nœud à analyser
+ * @param pattern - Pattern avec elementNodeType optionnel
+ * @returns Identifier ou undefined
+ */
+function extractIdentifierNode(node, pattern) {
+    // Vérifier elementNodeType si spécifié
+    if (pattern.elementNodeType) {
+        const nodeTypes = Array.isArray(pattern.elementNodeType)
+            ? pattern.elementNodeType
+            : [pattern.elementNodeType];
+        const nodeKind = node.getKindName();
+        if (!nodeTypes.includes(nodeKind)) {
+            return undefined;
+        }
+    }
+    // Extraire l'identifier
+    if (ts_morph_1.Node.isIdentifier(node)) {
+        return node;
+    }
+    if (ts_morph_1.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (ts_morph_1.Node.isIdentifier(expression)) {
+            return expression;
+        }
+    }
+    return undefined;
+}
+/**
+ * Vérifie si une définition matche le pattern referTo
+ * @param def - Définition à vérifier
+ * @param pattern - Pattern referTo
+ * @returns true si match
+ */
+function matchesDefinition(def, pattern) {
+    const targetNode = resolveToClassDeclaration(def);
+    if (!targetNode)
+        return false;
+    return checkDecoratorMatch(targetNode, pattern);
+}
+/**
+ * Résout une définition vers sa ClassDeclaration
+ * Gère les ImportSpecifier/ExportSpecifier avec résolution cross-file
+ *
+ * @param def - Définition (peut être ImportSpecifier, ExportSpecifier ou ClassDeclaration)
+ * @returns ClassDeclaration ou undefined
+ */
+function resolveToClassDeclaration(def) {
+    let targetNode = def;
+    // Si c'est un Import/ExportSpecifier, résoudre récursivement
+    if ((0, ast_helpers_1.isImportOrExportSpecifier)(def)) {
+        targetNode = resolveSpecifierRecursively(def);
+    }
+    return findParentClass(targetNode);
+}
+/**
+ * Vérifie si la ClassDeclaration a le bon décorateur avec les bonnes propriétés
+ * @param classDecl - ClassDeclaration à vérifier
+ * @param pattern - Pattern avec decorator et propertyNotEqual
+ * @returns true si match
+ */
+function checkDecoratorMatch(classDecl, pattern) {
+    const decorators = classDecl.getDecorators();
+    const targetDecorator = decorators.find(dec => getDecoratorName(dec) === pattern.decorator);
+    if (!targetDecorator)
+        return false;
+    if (pattern.propertyNotEqual) {
+        return checkPropertyNotEqual(targetDecorator, pattern.propertyNotEqual);
+    }
+    return true;
+}
+/**
+ * Trouve la classe parente d'une définition
+ */
+function findParentClass(def) {
+    if (ts_morph_1.Node.isClassDeclaration(def)) {
+        return def;
+    }
+    let current = def.getParent();
+    while (current && !ts_morph_1.Node.isClassDeclaration(current)) {
+        current = current.getParent();
+    }
+    return current;
+}
+/**
+ * Extrait le nom d'un décorateur
+ */
+function getDecoratorName(decorator) {
+    const expr = decorator.getExpression();
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        return expr.getExpression().getText();
+    }
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return expr.getText();
+    }
+    return undefined;
+}
+/**
+ * Vérifie si la propriété du décorateur ne correspond PAS à la valeur attendue
+ * @returns true si la propriété est absente OU différente de la valeur
+ */
+function checkPropertyNotEqual(decorator, propertyNotEqual) {
+    const { key, value } = propertyNotEqual;
+    const expr = decorator.getExpression();
+    // Si le décorateur n'a pas d'arguments, pas de config = match (car != value)
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return true;
+    }
+    if (!ts_morph_1.Node.isCallExpression(expr)) {
+        return false;
+    }
+    const args = expr.getArguments();
+    if (args.length === 0 || !ts_morph_1.Node.isObjectLiteralExpression(args[0])) {
+        return true;
+    }
+    const configObj = args[0];
+    const targetProp = configObj.getProperty(key);
+    if (!targetProp || !ts_morph_1.Node.isPropertyAssignment(targetProp)) {
+        return true;
+    }
+    const propValue = targetProp.getInitializer();
+    if (!propValue) {
+        return true;
+    }
+    const actualValue = propValue.getText().replace(/['"]/g, '');
+    return actualValue !== value;
+}

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesType = matchesType;
+exports.matchesReturnType = matchesReturnType;
+exports.matchesInitializer = matchesInitializer;
+exports.matchesObject = matchesObject;
+exports.matchesProperty = matchesProperty;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Vérifie le type TypeScript d'un nœud
+ */
+function matchesType(node, typePattern) {
+    let typeNode;
+    if (ts_morph_1.Node.isPropertyDeclaration(node) || ts_morph_1.Node.isParameterDeclaration(node)) {
+        typeNode = node.getTypeNode();
+    }
+    else if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        typeNode = node.getTypeNode();
+    }
+    if (!typeNode) {
+        return false;
+    }
+    const typeText = typeNode.getText();
+    // Vérifier string simple (comparaison exacte)
+    if (typeof typePattern === 'string') {
+        return typeText === typePattern;
+    }
+    // Vérifier containsAny
+    if (typeof typePattern === 'object' && typePattern.containsAny) {
+        return typePattern.containsAny.some((t) => typeText.includes(t));
+    }
+    // Vérifier union
+    if (typeof typePattern === 'object' && typePattern.union) {
+        if (ts_morph_1.Node.isUnionTypeNode(typeNode)) {
+            const types = typeNode.getTypeNodes().map(t => t.getText());
+            if (typePattern.union.contains) {
+                const hasAll = typePattern.union.contains.every((t) => types.includes(t));
+                if (!hasAll) {
+                    return false;
+                }
+            }
+            if (typePattern.union.missing) {
+                const missingTypes = Array.isArray(typePattern.union.missing)
+                    ? typePattern.union.missing
+                    : [typePattern.union.missing];
+                const hasAny = missingTypes.some((t) => types.includes(t));
+                if (hasAny) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    // Vérifier type simple
+    if (typeof typePattern === 'string') {
+        return typeText === typePattern;
+    }
+    return false;
+}
+/**
+ * Vérifie le type de retour d'une fonction
+ */
+function matchesReturnType(node, returnTypePattern) {
+    let returnTypeNode;
+    // Cas 1: FunctionDeclaration ou MethodDeclaration
+    if (ts_morph_1.Node.isFunctionDeclaration(node) || ts_morph_1.Node.isMethodDeclaration(node)) {
+        returnTypeNode = node.getReturnTypeNode();
+    }
+    // Cas 2: VariableDeclaration avec ArrowFunction initializer
+    else if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        const initializer = node.getInitializer();
+        if (initializer && ts_morph_1.Node.isArrowFunction(initializer)) {
+            returnTypeNode = initializer.getReturnTypeNode();
+        }
+    }
+    // Cas 3: ArrowFunction directement
+    else if (ts_morph_1.Node.isArrowFunction(node)) {
+        returnTypeNode = node.getReturnTypeNode();
+    }
+    else {
+        return false;
+    }
+    // Si pas de returnType, vérifier si on attend 'missing'
+    if (!returnTypeNode) {
+        if (returnTypePattern.missing) {
+            return true;
+        }
+        if (returnTypePattern.union && returnTypePattern.union.missing) {
+            return true;
+        }
+        return false;
+    }
+    const fullTypeText = returnTypeNode.getText();
+    // Vérifier union
+    if (returnTypePattern.union) {
+        // Cas simplifié: vérifier contains ET missing sur le texte complet
+        if (returnTypePattern.union.contains) {
+            const hasAll = returnTypePattern.union.contains.every((t) => fullTypeText.includes(t));
+            if (!hasAll) {
+                return false;
+            }
+        }
+        if (returnTypePattern.union.missing) {
+            const missingTypes = Array.isArray(returnTypePattern.union.missing)
+                ? returnTypePattern.union.missing
+                : [returnTypePattern.union.missing];
+            const hasAny = missingTypes.some((t) => fullTypeText.includes(t));
+            if (hasAny) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Vérifier missing
+    if (returnTypePattern.missing) {
+        const missingTypes = Array.isArray(returnTypePattern.missing)
+            ? returnTypePattern.missing
+            : [returnTypePattern.missing];
+        const hasAny = missingTypes.some((t) => fullTypeText.includes(t));
+        return !hasAny;
+    }
+    return false;
+}
+/**
+ * Vérifie l'initializer d'une propriété ou variable
+ */
+function matchesInitializer(node, initializerPattern, matchesAstPatternFn) {
+    let initializer;
+    if (ts_morph_1.Node.isPropertyDeclaration(node)) {
+        initializer = node.getInitializer();
+    }
+    else if (ts_morph_1.Node.isVariableDeclaration(node)) {
+        initializer = node.getInitializer();
+    }
+    else if (ts_morph_1.Node.isPropertyAssignment(node)) {
+        initializer = node.getInitializer();
+    }
+    if (!initializer) {
+        return false;
+    }
+    // Vérifier notWrappedIn
+    if (initializerPattern.notWrappedIn) {
+        if (ts_morph_1.Node.isCallExpression(initializer)) {
+            const funcName = initializer.getExpression().getText();
+            if (funcName === initializerPattern.notWrappedIn) {
+                return false;
+            }
+        }
+    }
+    // Vérifier le pattern de l'initializer
+    return matchesAstPatternFn(initializer, initializerPattern);
+}
+/**
+ * Vérifie si l'objet a une propriété spécifique
+ */
+function matchesObject(node, objectPattern) {
+    // Vérifier type simple
+    if (typeof objectPattern === 'string') {
+        if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+            const expressionText = node.getExpression().getText();
+            // Accepter soit "pendingTasks" soit "this.pendingTasks" soit "obj.pendingTasks"
+            return expressionText === objectPattern || expressionText.endsWith('.' + objectPattern);
+        }
+        if (ts_morph_1.Node.isIdentifier(node)) {
+            return node.getText() === objectPattern;
+        }
+        return false;
+    }
+    // Vérifier object avec type
+    if (objectPattern.type) {
+        if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+            const expr = node.getExpression();
+            if (ts_morph_1.Node.isIdentifier(expr)) {
+                // Vérifier le type via le type checker de ts-morph
+                try {
+                    const type = expr.getType();
+                    const typeText = type.getText();
+                    if (typeText.includes(objectPattern.type)) {
+                        return true;
+                    }
+                }
+                catch {
+                    // Si l'analyse de type échoue, fallback sur le nom de variable
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Vérifier properties (avec checkObjectProperties si nécessaire)
+    if (objectPattern.properties) {
+        // Pour l'instant, retourner true si l'objet existe
+        // Une vérification plus précise nécessiterait checkObjectProperties
+        return true;
+    }
+    return false;
+}
+/**
+ * Vérifie la propriété d'un PropertyAccessExpression
+ */
+function matchesProperty(node, property) {
+    if (!ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        return false;
+    }
+    return node.getName() === property;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Utilitaires partagés pour les matchers
+ * Évite la duplication de code (principe DRY)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureArray = ensureArray;
+exports.normalizeValue = normalizeValue;
+exports.matchesTextValue = matchesTextValue;
+/**
+ * Normalise une valeur en tableau
+ * @param value Valeur simple ou tableau
+ * @returns Tableau
+ */
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+/**
+ * Normalise une valeur en tant que string
+ * @param value Valeur à normaliser
+ * @returns String normalisée
+ */
+function normalizeValue(value) {
+    return String(value);
+}
+/**
+ * Vérifie si un texte correspond à une valeur (avec ou sans quotes)
+ * @param nodeText Texte du nœud
+ * @param expectedValue Valeur attendue
+ * @returns true si le texte correspond
+ */
+function matchesTextValue(nodeText, expectedValue) {
+    return nodeText === expectedValue ||
+        nodeText === `'${expectedValue}'` ||
+        nodeText === `"${expectedValue}"` ||
+        nodeText === `${expectedValue}`;
+}