@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,377 @@
+"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.HtmlMatcher = exports.SymbolMatcher = exports.FileMatcher = exports.CollectionMatcher = exports.TypeMatcher = exports.ExpressionMatcher = exports.HierarchyMatcher = exports.DecoratorMatcher = exports.ImportMatcher = exports.ContextMatcher = exports.NodeMatcher = exports.clearTemplateCache = void 0;
+exports.matchesAstPattern = matchesAstPattern;
+const ts_morph_1 = require("ts-morph");
+// Import matchers TypeScript (depuis ts/)
+const NodeMatcher = __importStar(require("./ts/node-matcher"));
+exports.NodeMatcher = NodeMatcher;
+const ContextMatcher = __importStar(require("./ts/context-matcher"));
+exports.ContextMatcher = ContextMatcher;
+const ImportMatcher = __importStar(require("./ts/import-matcher"));
+exports.ImportMatcher = ImportMatcher;
+const DecoratorMatcher = __importStar(require("./ts/decorator-matcher"));
+exports.DecoratorMatcher = DecoratorMatcher;
+const HierarchyMatcher = __importStar(require("./ts/hierarchy-matcher"));
+exports.HierarchyMatcher = HierarchyMatcher;
+const ExpressionMatcher = __importStar(require("./ts/expression-matcher"));
+exports.ExpressionMatcher = ExpressionMatcher;
+const TypeMatcher = __importStar(require("./ts/type-matcher"));
+exports.TypeMatcher = TypeMatcher;
+const CollectionMatcher = __importStar(require("./ts/collection-matcher"));
+exports.CollectionMatcher = CollectionMatcher;
+const FileMatcher = __importStar(require("./ts/file-matcher"));
+exports.FileMatcher = FileMatcher;
+const SymbolMatcher = __importStar(require("./ts/symbol-matcher"));
+exports.SymbolMatcher = SymbolMatcher;
+// Import matchers HTML (depuis html/)
+const HtmlMatcher = __importStar(require("./html"));
+exports.HtmlMatcher = HtmlMatcher;
+/**
+ * Fonction principale : vérifie si un nœud correspond à un pattern AST
+ * OPTIMISÉ : excludeContext en premier (88% des règles l'utilisent)
+ */
+function matchesAstPattern(node, pattern) {
+    // Gestion spéciale des patterns HTML purs (Attribute, PipeExpression)
+    if (HtmlMatcher.isHtmlPattern(pattern)) {
+        return HtmlMatcher.matchesHtmlPatternInComponent(node, pattern);
+    }
+    // 1. excludeContext EN PREMIER (88% des règles)
+    if (pattern.excludeContext) {
+        if (ContextMatcher.isInExcludedContext(node, pattern.excludeContext)) {
+            return false;
+        }
+    }
+    // 2. nodeType (rapide, mais souvent déjà filtré par getDescendantsOfKind)
+    if (pattern.nodeType) {
+        if (!NodeMatcher.matchesNodeType(node, pattern.nodeType)) {
+            return false;
+        }
+    }
+    // 3. Critères légers et fréquents
+    if (pattern.name !== undefined) {
+        if (!NodeMatcher.matchesName(node, pattern.name)) {
+            return false;
+        }
+    }
+    if (pattern.propertyName !== undefined) {
+        if (!NodeMatcher.matchesPropertyName(node, pattern.propertyName)) {
+            return false;
+        }
+    }
+    if (pattern.functionName !== undefined) {
+        if (!NodeMatcher.matchesFunctionName(node, pattern.functionName)) {
+            return false;
+        }
+    }
+    // 4. context requis (après excludeContext)
+    if (pattern.context) {
+        if (!ContextMatcher.matchesContext(node, pattern.context)) {
+            return false;
+        }
+    }
+    // Vérifier moduleSpecifier (pour ImportDeclaration)
+    if (pattern.moduleSpecifier !== undefined) {
+        if (!ImportMatcher.matchesModuleSpecifier(node, pattern.moduleSpecifier)) {
+            return false;
+        }
+    }
+    // Vérifier namedImports
+    if (pattern.namedImports !== undefined) {
+        if (!ImportMatcher.matchesNamedImports(node, pattern.namedImports)) {
+            return false;
+        }
+    }
+    // Vérifier les propriétés (pour Decorator, ObjectLiteral)
+    if (pattern.properties !== undefined) {
+        if (!DecoratorMatcher.matchesProperties(node, pattern.properties, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier template (pour @Component)
+    if (pattern.template !== undefined) {
+        if (!DecoratorMatcher.matchesTemplate(node, pattern.template)) {
+            return false;
+        }
+    }
+    // Vérifier arguments (pour CallExpression)
+    if (pattern.arguments !== undefined) {
+        if (!ExpressionMatcher.matchesArguments(node, pattern.arguments, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier initializer (valeur initiale)
+    if (pattern.initializer !== undefined) {
+        if (!TypeMatcher.matchesInitializer(node, pattern.initializer, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier parent
+    if (pattern.parent !== undefined) {
+        if (!HierarchyMatcher.matchesParent(node, pattern.parent, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier inClass
+    if (pattern.inClass !== undefined) {
+        if (!HierarchyMatcher.matchesInClass(node, pattern.inClass, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier notInClass
+    if (pattern.notInClass !== undefined) {
+        if (HierarchyMatcher.matchesInClass(node, pattern.notInClass, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier expression
+    if (pattern.expression !== undefined) {
+        if (!ExpressionMatcher.matchesExpression(node, pattern.expression, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier left (BinaryExpression)
+    if (pattern.left !== undefined) {
+        if (!ExpressionMatcher.matchesLeft(node, pattern.left, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier right (BinaryExpression)
+    if (pattern.right !== undefined) {
+        if (!ExpressionMatcher.matchesRight(node, pattern.right)) {
+            return false;
+        }
+    }
+    // Vérifier operatorKind
+    if (pattern.operatorKind !== undefined) {
+        if (!NodeMatcher.matchesOperatorKind(node, pattern.operatorKind)) {
+            return false;
+        }
+    }
+    // Vérifier type
+    if (pattern.type !== undefined) {
+        if (!TypeMatcher.matchesType(node, pattern.type)) {
+            return false;
+        }
+    }
+    // Vérifier returnType
+    if (pattern.returnType !== undefined) {
+        if (!TypeMatcher.matchesReturnType(node, pattern.returnType)) {
+            return false;
+        }
+    }
+    // Vérifier body
+    if (pattern.body !== undefined) {
+        if (!ExpressionMatcher.matchesBody(node, pattern.body, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier modifiers
+    if (pattern.modifiers !== undefined) {
+        if (!NodeMatcher.matchesModifiers(node, pattern.modifiers)) {
+            return false;
+        }
+    }
+    // Vérifier exported
+    if (pattern.exported !== undefined) {
+        if (!NodeMatcher.matchesExported(node, pattern.exported)) {
+            return false;
+        }
+    }
+    // Vérifier parameters
+    if (pattern.parameters !== undefined) {
+        if (!DecoratorMatcher.matchesParameters(node, pattern.parameters)) {
+            return false;
+        }
+    }
+    // Vérifier elements (ArrayLiteralExpression)
+    if (pattern.elements !== undefined) {
+        // Cas spécial: referTo dans elements (résolution de symboles cross-file)
+        if (typeof pattern.elements === 'object' && 'referTo' in pattern.elements) {
+            if (!ts_morph_1.Node.isArrayLiteralExpression(node)) {
+                return false;
+            }
+            const elements = node.getElements();
+            const elementsPattern = pattern.elements;
+            const hasMatch = elements.some(element => {
+                // Vérifier nodeType si présent dans le pattern elements
+                if (elementsPattern.nodeType) {
+                    if (!NodeMatcher.matchesNodeType(element, elementsPattern.nodeType)) {
+                        return false;
+                    }
+                }
+                // Vérifier referTo
+                return SymbolMatcher.matchesReferTo(element, elementsPattern.referTo);
+            });
+            if (!hasMatch) {
+                return false;
+            }
+        }
+        else {
+            // Logique normale (notEmpty, contains, etc.)
+            if (!CollectionMatcher.matchesElements(node, pattern.elements, matchesAstPattern)) {
+                return false;
+            }
+        }
+    }
+    // Vérifier ancestor
+    if (pattern.ancestor !== undefined) {
+        if (!HierarchyMatcher.matchesAncestor(node, pattern.ancestor, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier chainContains
+    if (pattern.chainContains !== undefined) {
+        if (!ExpressionMatcher.matchesChainContains(node, pattern.chainContains, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier containsAny
+    if (pattern.containsAny !== undefined) {
+        if (!CollectionMatcher.matchesContainsAny(node, pattern.containsAny, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier containsAll
+    if (pattern.containsAll !== undefined) {
+        if (!CollectionMatcher.matchesContainsAll(node, pattern.containsAll, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier value
+    if (pattern.value !== undefined) {
+        if (!NodeMatcher.matchesValue(node, pattern.value)) {
+            return false;
+        }
+    }
+    // Vérifier valueMatches
+    if (pattern.valueMatches !== undefined) {
+        if (!NodeMatcher.matchesValuePattern(node, pattern.valueMatches)) {
+            return false;
+        }
+    }
+    // Vérifier text
+    if (pattern.text !== undefined) {
+        if (!NodeMatcher.matchesText(node, pattern.text)) {
+            return false;
+        }
+    }
+    // Vérifier nextStatement
+    if (pattern.nextStatement !== undefined) {
+        if (!ContextMatcher.matchesNextStatement(node, pattern.nextStatement)) {
+            return false;
+        }
+    }
+    // Vérifier nextProvider
+    if (pattern.nextProvider !== undefined) {
+        if (!ContextMatcher.matchesNextProvider(node, pattern.nextProvider)) {
+            return false;
+        }
+    }
+    // Vérifier implements
+    if (pattern.implements !== undefined) {
+        if (!HierarchyMatcher.matchesImplements(node, pattern.implements)) {
+            return false;
+        }
+    }
+    // Vérifier implementsGeneric
+    if (pattern.implementsGeneric !== undefined) {
+        if (!HierarchyMatcher.matchesImplementsGeneric(node, pattern.implementsGeneric)) {
+            return false;
+        }
+    }
+    // Vérifier object
+    if (pattern.object !== undefined) {
+        if (!TypeMatcher.matchesObject(node, pattern.object)) {
+            return false;
+        }
+    }
+    // Vérifier property
+    if (pattern.property !== undefined) {
+        if (!TypeMatcher.matchesProperty(node, pattern.property)) {
+            return false;
+        }
+    }
+    // Vérifier declarations
+    if (pattern.declarations !== undefined) {
+        if (!DecoratorMatcher.matchesDeclarations(node, pattern.declarations, matchesAstPattern)) {
+            return false;
+        }
+    }
+    // Vérifier pipeName
+    if (pattern.pipeName !== undefined) {
+        if (!DecoratorMatcher.matchesPipeName(node, pattern.pipeName)) {
+            return false;
+        }
+    }
+    // Vérifier optionalChaining
+    if (pattern.optionalChaining !== undefined) {
+        if (!DecoratorMatcher.matchesOptionalChaining(node, pattern.optionalChaining)) {
+            return false;
+        }
+    }
+    // Vérifier nonNullAssertion
+    if (pattern.nonNullAssertion !== undefined) {
+        if (!DecoratorMatcher.matchesNonNullAssertion(node, pattern.nonNullAssertion)) {
+            return false;
+        }
+    }
+    // Vérifier inFile (nom de fichier)
+    if (pattern.inFile !== undefined) {
+        const sourceFile = node.getSourceFile();
+        const filePath = sourceFile.getFilePath();
+        if (!FileMatcher.matchesInFilePattern(filePath, pattern.inFile)) {
+            return false;
+        }
+    }
+    // Vérifier testSetup
+    if (pattern.testSetup !== undefined) {
+        const sourceFile = node.getSourceFile();
+        if (!FileMatcher.matchesTestSetup(sourceFile, pattern.testSetup)) {
+            return false;
+        }
+    }
+    // Vérifier referTo (résolution de symboles cross-file au niveau racine)
+    if (pattern.referTo !== undefined) {
+        if (!SymbolMatcher.matchesReferTo(node, pattern.referTo)) {
+            return false;
+        }
+    }
+    return true;
+}
+// Export des fonctions utilitaires de cache
+var decorator_matcher_1 = require("./ts/decorator-matcher");
+Object.defineProperty(exports, "clearTemplateCache", { enumerable: true, get: function () { return decorator_matcher_1.clearTemplateCache; } });

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesElements = matchesElements;
+exports.matchesContainsAny = matchesContainsAny;
+exports.matchesContainsAll = matchesContainsAll;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Vérifie les éléments d'un tableau (ArrayLiteralExpression)
+ */
+function matchesElements(node, elementsPattern, matchesAstPatternFn) {
+    if (!ts_morph_1.Node.isArrayLiteralExpression(node)) {
+        return false;
+    }
+    const elements = node.getElements();
+    // Vérifier notEmpty (tableau doit avoir au moins un élément)
+    if (typeof elementsPattern === 'object' && elementsPattern.notEmpty === true) {
+        return elements.length > 0;
+    }
+    // Vérifier contains (au moins un élément matche le pattern)
+    if (elementsPattern.contains) {
+        return elements.some(element => matchesAstPatternFn(element, elementsPattern.contains));
+    }
+    // Cas où elementsPattern est directement un pattern AST
+    return elements.some(element => matchesAstPatternFn(element, elementsPattern));
+}
+/**
+ * Vérifie qu'au moins un sous-pattern matche (containsAny)
+ */
+function matchesContainsAny(node, patterns, matchesAstPatternFn) {
+    let hasMatch = false;
+    node.forEachDescendant((child) => {
+        if (patterns.some(pattern => matchesAstPatternFn(child, pattern))) {
+            hasMatch = true;
+        }
+    });
+    return hasMatch;
+}
+/**
+ * Vérifie que tous les sous-patterns matchent (containsAll)
+ */
+function matchesContainsAll(node, patterns, matchesAstPatternFn) {
+    const matches = new Set();
+    node.forEachDescendant((child) => {
+        patterns.forEach((pattern, index) => {
+            if (matchesAstPatternFn(child, pattern)) {
+                matches.add(index);
+            }
+        });
+    });
+    return matches.size === patterns.length;
+}

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

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearContextCaches = clearContextCaches;
+exports.isInExcludedContext = isInExcludedContext;
+exports.matchesNextStatement = matchesNextStatement;
+exports.matchesNextProvider = matchesNextProvider;
+exports.matchesContext = matchesContext;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Cache pour les résultats de vérification excludeContext
+ * Évite de refaire les mêmes traversals coûteux
+ */
+let excludeContextCache = new WeakMap();
+/**
+ * Cache des comment ranges par fichier (calculé une seule fois)
+ */
+let commentRangesCache = new WeakMap();
+/**
+ * Vide les caches pour libérer la mémoire entre les batches
+ * CRITIQUE : Appeler après removeSourceFile() pour forcer GC immédiat
+ */
+function clearContextCaches() {
+    excludeContextCache = new WeakMap();
+    commentRangesCache = new WeakMap();
+}
+/**
+ * Récupère les comment ranges d'un fichier (avec cache)
+ */
+function getCommentRanges(sourceFile) {
+    let cached = commentRangesCache.get(sourceFile);
+    if (cached) {
+        return cached;
+    }
+    const leadingComments = sourceFile.getLeadingCommentRanges() || [];
+    const trailingComments = sourceFile.getTrailingCommentRanges() || [];
+    cached = [...leadingComments, ...trailingComments].map(range => ({
+        pos: range.getPos(),
+        end: range.getEnd()
+    }));
+    commentRangesCache.set(sourceFile, cached);
+    return cached;
+}
+/**
+ * Vérifie si le nœud est dans un commentaire (optimisé avec cache)
+ */
+function isNodeInComment(node) {
+    const sourceFile = node.getSourceFile();
+    const start = node.getStart();
+    const commentRanges = getCommentRanges(sourceFile);
+    return commentRanges.some(range => start >= range.pos && start <= range.end);
+}
+/**
+ * Vérifie si le nœud est dans un StringLiteral (optimisé, limite profondeur)
+ */
+function isNodeInStringLiteral(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    // Augmenté à 20 pour gérer les objets profondément imbriqués (Nx, configs complexes)
+    // Exemple: const config = { a: { b: { c: { d: "string" } } } } → profondeur 12+
+    const MAX_DEPTH = 20;
+    while (parent && depth < MAX_DEPTH) {
+        if (ts_morph_1.Node.isStringLiteral(parent)) {
+            return true;
+        }
+        // Optimisation: arrêter si on atteint un SourceFile
+        if (ts_morph_1.Node.isSourceFile(parent)) {
+            return false;
+        }
+        parent = parent.getParent();
+        depth++;
+    }
+    return false;
+}
+/**
+ * Vérifie si le nœud est dans un ImportSpecifier (optimisé, limite profondeur)
+ */
+function isNodeInImportSpecifier(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    // Augmenté à 10 pour cohérence (ImportSpecifier est généralement à profondeur 3-4)
+    const MAX_DEPTH = 10;
+    while (parent && depth < MAX_DEPTH) {
+        if (ts_morph_1.Node.isImportSpecifier(parent)) {
+            return true;
+        }
+        if (ts_morph_1.Node.isSourceFile(parent)) {
+            return false;
+        }
+        parent = parent.getParent();
+        depth++;
+    }
+    return false;
+}
+/**
+ * Vérifie si le nœud est dans un contexte exclu (StringLiteral, Comment)
+ * OPTIMISÉ avec cache et early exit
+ */
+function isInExcludedContext(node, excludeContext) {
+    // Vérifier le cache
+    const cached = excludeContextCache.get(node);
+    if (cached) {
+        return excludeContext.some(ctx => cached.has(ctx));
+    }
+    // Calculer les contextes (seulement ceux demandés)
+    const contexts = new Set();
+    // Vérifier seulement les contextes demandés (optimisation)
+    if (excludeContext.includes('StringLiteral')) {
+        if (isNodeInStringLiteral(node)) {
+            contexts.add('StringLiteral');
+        }
+    }
+    if (excludeContext.includes('Comment')) {
+        if (isNodeInComment(node)) {
+            contexts.add('Comment');
+        }
+    }
+    if (excludeContext.includes('ImportSpecifier')) {
+        if (isNodeInImportSpecifier(node)) {
+            contexts.add('ImportSpecifier');
+        }
+    }
+    // Mettre en cache
+    excludeContextCache.set(node, contexts);
+    // Vérifier si au moins un contexte exclu est présent
+    return excludeContext.some(ctx => contexts.has(ctx));
+}
+/**
+ * Vérifie la prochaine instruction (nextStatement)
+ */
+function matchesNextStatement(node, nextStatementPattern) {
+    // Trouver le statement parent
+    let currentStatement = node;
+    while (currentStatement && !ts_morph_1.Node.isStatement(currentStatement)) {
+        currentStatement = currentStatement.getParent();
+    }
+    if (!currentStatement) {
+        return false;
+    }
+    const parent = currentStatement.getParent();
+    if (!parent) {
+        return false;
+    }
+    let statements = [];
+    // Récupérer les statements selon le type de parent
+    if (ts_morph_1.Node.isBlock(parent)) {
+        statements = parent.getStatements();
+    }
+    else if (ts_morph_1.Node.isSourceFile(parent)) {
+        statements = parent.getStatements();
+    }
+    else if (ts_morph_1.Node.isCaseClause(parent) || ts_morph_1.Node.isDefaultClause(parent)) {
+        statements = parent.getStatements();
+    }
+    else {
+        return false;
+    }
+    const currentIndex = statements.indexOf(currentStatement);
+    if (currentIndex === -1) {
+        return false;
+    }
+    // Vérifier notContains : matcher si le pattern est absent du statement suivant
+    if (nextStatementPattern.notContains) {
+        // Si pas de statement suivant, le pattern est bien absent → match
+        if (currentIndex === statements.length - 1) {
+            return true;
+        }
+        const nextStatement = statements[currentIndex + 1];
+        const nextText = nextStatement.getText();
+        // Vérifier si au moins un des patterns est présent dans le statement suivant
+        const hasAny = nextStatementPattern.notContains.some((pattern) => nextText.includes(pattern));
+        // Matcher si AUCUN pattern n'est présent
+        return !hasAny;
+    }
+    return true;
+}
+/**
+ * Vérifie le provider suivant (nextProvider)
+ */
+function matchesNextProvider(node, nextProviderPattern) {
+    // Trouver le tableau de providers parent
+    let parent = node.getParent();
+    while (parent && !ts_morph_1.Node.isArrayLiteralExpression(parent)) {
+        parent = parent.getParent();
+    }
+    if (!parent || !ts_morph_1.Node.isArrayLiteralExpression(parent)) {
+        return false;
+    }
+    const elements = parent.getElements();
+    const currentIndex = elements.indexOf(node);
+    if (currentIndex === -1) {
+        return false;
+    }
+    // Vérifier missing : le provider ne doit PAS être présent dans les éléments restants
+    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++) {
+            const providerElement = elements[i];
+            const providerText = providerElement.getText();
+            // Vérifier si le provider manquant est présent
+            if (providerText.includes(missingProviderName)) {
+                // Le provider est présent, donc le pattern ne matche PAS
+                return false;
+            }
+        }
+        // Le provider est bien absent de tous les providers restants
+        return true;
+    }
+    return true;
+}
+/**
+ * Vérifie le contexte requis (context)
+ */
+function matchesContext(node, context) {
+    // Convertir en tableau si c'est une chaîne unique
+    const contexts = Array.isArray(context) ? context : [context];
+    // Contextes spéciaux personnalisés
+    if (contexts.includes('ProvidersArray')) {
+        if (isInProvidersArray(node)) {
+            return true;
+        }
+    }
+    // Contextes AST standards
+    let parent = node.getParent();
+    while (parent) {
+        const parentKind = parent.getKindName();
+        if (contexts.includes(parentKind)) {
+            return true;
+        }
+        parent = parent.getParent();
+    }
+    return false;
+}
+/**
+ * Vérifie si le nœud est dans un tableau providers d'un @NgModule ou @Component
+ */
+function isInProvidersArray(node) {
+    // Vérifier si le nœud est dans un ArrayLiteralExpression
+    let parent = node.getParent();
+    while (parent) {
+        // Si on trouve un ArrayLiteralExpression, vérifier si c'est un tableau providers
+        if (ts_morph_1.Node.isArrayLiteralExpression(parent)) {
+            const propAssignment = parent.getParent();
+            // Vérifier si c'est une PropertyAssignment avec le nom "providers"
+            if (propAssignment && ts_morph_1.Node.isPropertyAssignment(propAssignment)) {
+                const propName = propAssignment.getName();
+                if (propName === 'providers') {
+                    // Vérifier si la PropertyAssignment est dans un ObjectLiteralExpression
+                    const objLiteral = propAssignment.getParent();
+                    if (objLiteral && ts_morph_1.Node.isObjectLiteralExpression(objLiteral)) {
+                        // Vérifier si l'ObjectLiteralExpression est dans un CallExpression (argument du décorateur)
+                        const callExpr = objLiteral.getParent();
+                        if (callExpr && ts_morph_1.Node.isCallExpression(callExpr)) {
+                            // Vérifier si le CallExpression est dans un Decorator
+                            const decorator = callExpr.getParent();
+                            if (decorator && ts_morph_1.Node.isDecorator(decorator)) {
+                                // Vérifier si le décorateur est @NgModule ou @Component
+                                const expr = decorator.getExpression();
+                                if (ts_morph_1.Node.isCallExpression(expr)) {
+                                    const decoratorName = expr.getExpression().getText();
+                                    return decoratorName === 'NgModule' || decoratorName === 'Component';
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // On a trouvé un ArrayLiteralExpression mais ce n'est pas providers
+            // Ne pas continuer la recherche plus haut
+            return false;
+        }
+        parent = parent.getParent();
+    }
+    return false;
+}