@silvestv/migration-planificator 3.0.0

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

@@ -0,0 +1,134 @@
+"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.analyzeApp = analyzeApp;
+exports.analyzeLib = analyzeLib;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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$/);
+    return {
+        name: appName,
+        description,
+        path: appPath,
+        dependencies,
+        devDependencies,
+        components,
+        modules,
+        services,
+        directives,
+        pipes,
+        guards,
+        interceptors,
+        resolvers
+    };
+}
+/**
+ * Analyse les détails d'une librairie Angular (Nx uniquement)
+ */
+function analyzeLib(libName, projectPath) {
+    const libPath = path.join(projectPath, 'libs', libName);
+    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)(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
+    };
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttributeValue = getAttributeValue;
+exports.matchesAttributePattern = matchesAttributePattern;
+const html_parser_1 = require("./html-parser");
+const matcher_helpers_1 = require("../utils/matcher-helpers");
+/**
+ * Récupère le nom d'un attribut
+ */
+function getAttributeName(attr) {
+    if ('name' in attr) {
+        return attr.name;
+    }
+    if ('key' in attr && 'span' in attr.key) {
+        return attr.key.span.toString();
+    }
+    return '';
+}
+/**
+ * Récupère la valeur d'un attribut
+ */
+function getAttributeValue(attr) {
+    // BoundAttribute (property binding like [ngModel] or [(ngModel)])
+    if ('value' in attr && attr.value) {
+        if (typeof attr.value === 'string') {
+            return attr.value;
+        }
+        // Pour les inputs bindings, la valeur est dans value.source
+        if ('source' in attr.value) {
+            return attr.value.source;
+        }
+    }
+    // TextAttribute (regular attribute)
+    if ('value' in attr && typeof attr.value === 'string') {
+        return attr.value;
+    }
+    return '';
+}
+/**
+ * Vérifie si un attribut/input contient des erreurs de parsing
+ * (utilisé pour détecter des assignations interdites dans [(ngModel)])
+ */
+function hasBindingErrors(attr) {
+    if ('value' in attr && attr.value && 'errors' in attr.value && Array.isArray(attr.value.errors)) {
+        return attr.value.errors.length > 0;
+    }
+    return false;
+}
+/**
+ * Matche un pattern Attribute (*ngIf, *ngFor, [(ngModel)], etc.)
+ */
+function matchesAttributePattern(element, pattern, htmlContent) {
+    const patternNames = (0, matcher_helpers_1.ensureArray)(pattern.name);
+    // Vérifier les attributs de l'élément (attributes, inputs, templateAttrs)
+    const allAttributes = [
+        ...element.attributes,
+        ...element.inputs,
+        ...(element.templateAttrs || [])
+    ];
+    for (const attr of allAttributes) {
+        let attrName = getAttributeName(attr);
+        // Pour les directives structurelles, ajouter le préfixe *
+        if (element.templateAttrs && element.templateAttrs.includes(attr)) {
+            attrName = '*' + attrName;
+        }
+        if (patternNames.includes(attrName)) {
+            // Vérifier valueMatches si spécifié
+            if (pattern.valueMatches) {
+                const attrValue = getAttributeValue(attr);
+                const valueRegex = new RegExp(pattern.valueMatches);
+                // Pour ngModel, on peut aussi utiliser les erreurs de parsing Angular
+                const hasErrors = hasBindingErrors(attr);
+                const valueMatches = valueRegex.test(attrValue);
+                // Si ni la regex ne matche, ni d'erreurs détectées, skip
+                if (!valueMatches && !hasErrors) {
+                    continue;
+                }
+            }
+            return {
+                lineNumber: (0, html_parser_1.getLineNumber)(attr, htmlContent),
+                matchedText: (0, html_parser_1.getNodeText)(element, htmlContent)
+            };
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesHtmlPatternInComponent = matchesHtmlPatternInComponent;
+const index_1 = require("./index");
+/**
+ * Vérifie si un nœud Decorator @Component contient un template HTML qui matche le pattern
+ * Extrait le template du @Component et utilise findHtmlPatternMatches
+ */
+function matchesHtmlPatternInComponent(node, pattern) {
+    // Le nœud doit être un Decorator @Component
+    if (!node.getKindName || node.getKindName() !== 'Decorator') {
+        return false;
+    }
+    // Extraire le template du @Component
+    const expression = node.getExpression();
+    if (!expression || !expression.getKindName || expression.getKindName() !== 'CallExpression') {
+        return false;
+    }
+    const args = expression.getArguments();
+    if (args.length === 0) {
+        return false;
+    }
+    const configObject = args[0];
+    if (!configObject || configObject.getKindName() !== 'ObjectLiteralExpression') {
+        return false;
+    }
+    const templateProperty = configObject.getProperty('template');
+    if (!templateProperty) {
+        return false;
+    }
+    const templateValue = templateProperty.getInitializer();
+    if (!templateValue) {
+        return false;
+    }
+    // Extraire le texte du template et retirer les quotes/backticks
+    const templateContent = templateValue.getText().replace(/^[`'"]+|[`'"]+$/g, '');
+    // Utiliser findHtmlPatternMatches pour vérifier le pattern
+    const matches = (0, index_1.findHtmlPatternMatches)(templateContent, pattern);
+    return matches.length > 0;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesElementPattern = matchesElementPattern;
+exports.matchesDeferredBlockPattern = matchesDeferredBlockPattern;
+const html_parser_1 = require("./html-parser");
+const matcher_helpers_1 = require("../utils/matcher-helpers");
+/**
+ * Matche un pattern Element (ng-content, div, etc.)
+ */
+function matchesElementPattern(node, pattern, htmlContent) {
+    // Vérifier si c'est un Element ou Content (ng-content)
+    const isContentOrElement = node.constructor &&
+        (node.constructor.name === 'Element' || node.constructor.name === 'Content');
+    if (!isContentOrElement || !node.name) {
+        return null;
+    }
+    const patternNames = (0, matcher_helpers_1.ensureArray)(pattern.name);
+    if (!patternNames.includes(node.name)) {
+        return null;
+    }
+    // Vérifier hasChildren si spécifié
+    if (pattern.hasChildren !== undefined) {
+        // Filtrer les enfants pour exclure les whitespace-only Text nodes
+        const nonWhitespaceChildren = node.children?.filter((child) => {
+            // Si c'est un Text node, vérifier s'il contient autre chose que du whitespace
+            if (child.constructor?.name === 'Text') {
+                return child.value && child.value.trim().length > 0;
+            }
+            // Les autres types de nœuds (Element, Comment, etc.) sont toujours considérés
+            return true;
+        }) || [];
+        const hasChildren = nonWhitespaceChildren.length > 0;
+        if (pattern.hasChildren !== hasChildren) {
+            return null;
+        }
+    }
+    return {
+        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
+    };
+}
+/**
+ * Matche un pattern DeferredBlock (@defer blocks)
+ */
+function matchesDeferredBlockPattern(node, 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)
+        };
+    }
+    return null;
+}

package/dist/src/core/ast/matchers/html/html-parser.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHtmlTemplate = parseHtmlTemplate;
+exports.getLineNumber = getLineNumber;
+exports.getNodeText = getNodeText;
+exports.isElement = isElement;
+const compiler_1 = require("@angular/compiler");
+/**
+ * Parse un template HTML Angular et retourne l'AST
+ * NOTE: Retourne les nœuds même en présence d'erreurs de parsing
+ * (certaines erreurs sont précisément ce qu'on cherche à détecter)
+ * Support complet Angular 18-20: @if, @for, @switch, @defer, @let
+ */
+function parseHtmlTemplate(htmlContent) {
+    try {
+        const parsed = (0, compiler_1.parseTemplate)(htmlContent, '', {
+            preserveWhitespaces: false,
+            interpolationConfig: undefined,
+            enableBlockSyntax: true, // Support @if, @for, @switch, @defer
+            enableLetSyntax: true // Support @let
+        });
+        return parsed.nodes;
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Trouve le numéro de ligne d'un nœud dans le template
+ */
+function getLineNumber(node, htmlContent) {
+    if (node.sourceSpan && node.sourceSpan.start && node.sourceSpan.start.line !== undefined) {
+        return node.sourceSpan.start.line + 1; // Angular utilise 0-indexed
+    }
+    // Fallback: estimer via l'offset
+    if (node.sourceSpan && node.sourceSpan.start && node.sourceSpan.start.offset !== undefined) {
+        const textBeforeNode = htmlContent.substring(0, node.sourceSpan.start.offset);
+        return textBeforeNode.split('\n').length;
+    }
+    return 1;
+}
+/**
+ * Extrait le texte d'un nœud
+ */
+function getNodeText(node, htmlContent) {
+    if (node.sourceSpan && node.sourceSpan.start && node.sourceSpan.end) {
+        const start = node.sourceSpan.start.offset;
+        const end = node.sourceSpan.end.offset;
+        return htmlContent.substring(start, end).trim();
+    }
+    return '';
+}
+/**
+ * Vérifie si un nœud est un Element
+ */
+function isElement(node) {
+    return 'attributes' in node && 'inputs' in node;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesPipePattern = matchesPipePattern;
+exports.traversePipeExpression = traversePipeExpression;
+const html_parser_1 = require("./html-parser");
+/**
+ * Extrait la valeur d'un argument de pipe
+ */
+function getPipeArgumentValue(arg) {
+    if (!arg)
+        return '';
+    // LiteralPrimitive (string literal dans l'AST)
+    if ('value' in arg && typeof arg.value === 'string') {
+        return arg.value;
+    }
+    // Pour autres types d'expressions, utiliser source si disponible
+    if ('source' in arg && typeof arg.source === 'string') {
+        return arg.source;
+    }
+    // Fallback: essayer d'extraire le texte brut
+    if (typeof arg === 'string') {
+        return arg;
+    }
+    return '';
+}
+/**
+ * Matche un pattern PipeExpression (| async, | date, etc.)
+ */
+function matchesPipePattern(node, pattern, htmlContent) {
+    if (!pattern.pipeName) {
+        return null;
+    }
+    // Vérifier si c'est un BindingPipe avec le bon nom
+    if (!node.name || node.name !== pattern.pipeName) {
+        return null;
+    }
+    // Si le pattern spécifie des contraintes sur les arguments de pipe
+    if (pattern.pipeArgs && pattern.pipeArgs.formatMatches) {
+        // Vérifier que la pipe a des arguments
+        if (!node.args || node.args.length === 0) {
+            return null;
+        }
+        const firstArgValue = getPipeArgumentValue(node.args[0]);
+        const formatRegex = new RegExp(pattern.pipeArgs.formatMatches);
+        // Matcher uniquement si le format correspond
+        if (!formatRegex.test(firstArgValue)) {
+            return null;
+        }
+        return {
+            lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+            matchedText: (0, html_parser_1.getNodeText)(node, htmlContent).substring(0, 100)
+        };
+    }
+    // Pas de contrainte sur les args, match basé sur le nom de pipe seul
+    const nodeText = (0, html_parser_1.getNodeText)(node, htmlContent);
+    const pipeRegex = new RegExp(`\\|\\s*${pattern.pipeName}\\b`);
+    if (pipeRegex.test(nodeText)) {
+        return {
+            lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+            matchedText: nodeText.substring(0, 100)
+        };
+    }
+    return null;
+}
+/**
+ * Parcourt récursivement une expression AST à la recherche de BindingPipe
+ */
+function traversePipeExpression(expr, pattern, htmlContent, matches) {
+    if (!expr)
+        return;
+    // Si pattern cherche une PipeExpression, chercher BindingPipe
+    if (pattern.nodeType === 'PipeExpression' && pattern.pipeName) {
+        if (expr.constructor && expr.constructor.name === 'BindingPipe') {
+            const match = matchesPipePattern(expr, pattern, htmlContent);
+            if (match) {
+                matches.push(match);
+            }
+        }
+    }
+    // Parcourir les expressions d'une Interpolation
+    if (expr.expressions && Array.isArray(expr.expressions)) {
+        for (const subExpr of expr.expressions) {
+            traversePipeExpression(subExpr, pattern, htmlContent, matches);
+        }
+    }
+    // Parcourir récursivement les sous-expressions
+    if (expr.exp) {
+        traversePipeExpression(expr.exp, pattern, htmlContent, matches);
+    }
+    if (expr.args && Array.isArray(expr.args)) {
+        for (const arg of expr.args) {
+            traversePipeExpression(arg, pattern, htmlContent, matches);
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesBoundTextPattern = matchesBoundTextPattern;
+const html_parser_1 = require("./html-parser");
+/**
+ * Matche un pattern BoundText (interpolations {{ ... }})
+ */
+function matchesBoundTextPattern(node, pattern, htmlContent) {
+    // Vérifier si c'est bien un BoundText (interpolation) et non un Text simple
+    if (!('value' in node) || !node.value || typeof node.value !== 'object') {
+        return null;
+    }
+    // Vérifier textMatches si spécifié
+    if (!pattern.textMatches) {
+        return null;
+    }
+    const textRegex = new RegExp(pattern.textMatches);
+    // value.ast contient l'AST de l'expression (Interpolation, etc.)
+    const ast = node.value.ast;
+    // Si l'AST est une Interpolation avec expressions
+    if (ast && ast.expressions && Array.isArray(ast.expressions)) {
+        for (const expr of ast.expressions) {
+            // Pour LiteralPrimitive (mots-clés comme 'in')
+            if (expr.value !== undefined && typeof expr.value === 'string') {
+                if (textRegex.test(expr.value)) {
+                    return {
+                        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+                        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
+                    };
+                }
+            }
+            // Pour VoidExpression (Angular parse 'void' comme opérateur)
+            if (expr.constructor && expr.constructor.name === 'VoidExpression') {
+                if (textRegex.test('void')) {
+                    return {
+                        lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+                        matchedText: (0, html_parser_1.getNodeText)(node, htmlContent)
+                    };
+                }
+            }
+        }
+    }
+    // Fallback: tester le source complet
+    if ('source' in node.value && typeof node.value.source === 'string') {
+        if (textRegex.test(node.value.source)) {
+            return {
+                lineNumber: (0, html_parser_1.getLineNumber)(node, htmlContent),
+                matchedText: node.value.source
+            };
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesHtmlPatternInComponent = void 0;
+exports.findHtmlPatternMatches = findHtmlPatternMatches;
+exports.isHtmlPattern = isHtmlPattern;
+const html_parser_1 = require("./html-parser");
+const html_attribute_matcher_1 = require("./html-attribute-matcher");
+const html_element_matcher_1 = require("./html-element-matcher");
+const html_text_matcher_1 = require("./html-text-matcher");
+const html_pipe_matcher_1 = require("./html-pipe-matcher");
+/**
+ * Vérifie si un nœud HTML correspond à un pattern AST HTML
+ * Supporte : Attribute, 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)) {
+        return (0, html_attribute_matcher_1.matchesAttributePattern)(node, pattern, htmlContent);
+    }
+    // Pattern: Element (ng-content, div, etc.)
+    if (pattern.nodeType === 'Element') {
+        return (0, html_element_matcher_1.matchesElementPattern)(node, pattern, htmlContent);
+    }
+    // Pattern: DeferredBlock (@defer blocks)
+    if (pattern.nodeType === 'DeferredBlock') {
+        return (0, html_element_matcher_1.matchesDeferredBlockPattern)(node, htmlContent);
+    }
+    // Pattern: PipeExpression (| async, | date, etc.)
+    if (pattern.nodeType === 'PipeExpression' && pattern.pipeName) {
+        return (0, html_pipe_matcher_1.matchesPipePattern)(node, pattern, htmlContent);
+    }
+    return null;
+}
+/**
+ * Parcourt récursivement l'AST HTML et trouve les matches
+ */
+function traverseHtmlAst(nodes, pattern, htmlContent, matches) {
+    for (const node of nodes) {
+        // Vérifier si le nœud matche
+        const match = matchesHtmlNode(node, pattern, htmlContent);
+        if (match) {
+            matches.push(match);
+        }
+        // Si pattern cherche PipeExpression et node est BoundText, parcourir son expression
+        if (pattern.nodeType === 'PipeExpression' && 'value' in node && node.value) {
+            const value = node.value;
+            // value est ASTWithSource, l'AST réel est dans value.ast
+            if (value.ast) {
+                (0, html_pipe_matcher_1.traversePipeExpression)(value.ast, pattern, htmlContent, matches);
+            }
+            else {
+                (0, html_pipe_matcher_1.traversePipeExpression)(value, pattern, htmlContent, matches);
+            }
+        }
+        // 1. Parcourir les enfants standards
+        if ('children' in node && Array.isArray(node.children)) {
+            traverseHtmlAst(node.children, pattern, htmlContent, matches);
+        }
+        // 2. Parcourir les branches (@if, @else if, @else)
+        if ('branches' in node && Array.isArray(node.branches)) {
+            for (const branch of node.branches) {
+                if (branch.children && Array.isArray(branch.children)) {
+                    traverseHtmlAst(branch.children, pattern, htmlContent, matches);
+                }
+            }
+        }
+        // 3. Parcourir les cases (@switch, @case, @default)
+        if ('cases' in node && Array.isArray(node.cases)) {
+            for (const caseNode of node.cases) {
+                if (caseNode.children && Array.isArray(caseNode.children)) {
+                    traverseHtmlAst(caseNode.children, pattern, htmlContent, matches);
+                }
+            }
+        }
+        // 4. Parcourir @for @empty
+        if ('empty' in node && node.empty?.children) {
+            traverseHtmlAst(node.empty.children, pattern, htmlContent, matches);
+        }
+        // 5-8. Parcourir @defer sub-blocks (mainBlock, placeholder, loading, error)
+        const deferSubBlocks = ['mainBlock', 'placeholder', 'loading', 'error'];
+        for (const blockName of deferSubBlocks) {
+            if (blockName in node && node[blockName]?.children) {
+                traverseHtmlAst(node[blockName].children, pattern, htmlContent, matches);
+            }
+        }
+    }
+}
+/**
+ * Trouve les matches d'un pattern AST HTML dans un template
+ * @param htmlContent Contenu du template HTML
+ * @param pattern Pattern AST à rechercher
+ * @returns Liste des matches trouvés
+ */
+function findHtmlPatternMatches(htmlContent, pattern) {
+    const matches = [];
+    // Parser le template HTML
+    const ast = (0, html_parser_1.parseHtmlTemplate)(htmlContent);
+    // Parcourir l'AST et trouver les matches
+    traverseHtmlAst(ast, pattern, htmlContent, matches);
+    return matches;
+}
+/**
+ * Vérifie si un pattern est un pattern HTML
+ * (nécessite @angular/compiler)
+ */
+function isHtmlPattern(pattern) {
+    return pattern.nodeType === 'Attribute' ||
+        pattern.nodeType === 'PipeExpression' ||
+        pattern.nodeType === 'BoundText' ||
+        pattern.nodeType === 'Element' ||
+        pattern.nodeType === 'DeferredBlock';
+}
+var html_component_matcher_1 = require("./html-component-matcher");
+Object.defineProperty(exports, "matchesHtmlPatternInComponent", { enumerable: true, get: function () { return html_component_matcher_1.matchesHtmlPatternInComponent; } });