@silvestv/migration-planificator 3.0.0

package/dist/src/templates/workload/rule-modal.template.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Template pour modals de détails de règles
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRuleModals = renderRuleModals;
+exports.renderDescriptionSection = renderDescriptionSection;
+exports.renderCodeExamplesSection = renderCodeExamplesSection;
+exports.renderMigrationCommandSection = renderMigrationCommandSection;
+exports.renderDocumentationSection = renderDocumentationSection;
+exports.renderAffectedFilesSection = renderAffectedFilesSection;
+exports.renderMetadataSection = renderMetadataSection;
+const shared_1 = require("../../utils/shared");
+/**
+ * Génère tous les modals pour les règles
+ */
+function renderRuleModals(rules, matches) {
+    // Grouper matches par ruleKey
+    const matchesByRule = new Map();
+    matches.forEach(match => {
+        if (!matchesByRule.has(match.ruleKey)) {
+            matchesByRule.set(match.ruleKey, []);
+        }
+        matchesByRule.get(match.ruleKey).push(match);
+    });
+    return rules.map(rule => renderRuleModal(rule, matchesByRule.get(rule.key) || [])).join('');
+}
+/**
+ * Génère le HTML d'une modal pour une règle
+ */
+function renderRuleModal(rule, matches) {
+    const modalId = `modal-${rule.key}`;
+    const riskColor = getRiskColor(rule.risk_level);
+    return `
+        <div id="${modalId}" class="fixed inset-0 z-50 hidden">
+            <div class="fixed inset-0 bg-black bg-opacity-50" data-modal-overlay></div>
+            <div class="fixed inset-0 flex items-center justify-center p-4">
+                <div class="bg-white rounded-xl shadow-2xl max-w-4xl w-full max-h-[90vh] overflow-auto relative">
+                    ${renderModalHeader(rule, riskColor)}
+                    ${renderModalBody(rule, matches)}
+                    ${renderModalFooter()}
+                </div>
+            </div>
+        </div>
+    `;
+}
+/**
+ * Retourne la couleur du badge selon le niveau de risque
+ */
+function getRiskColor(riskLevel) {
+    const colorMap = {
+        critical: 'red',
+        high: 'orange',
+        medium: 'yellow',
+        low: 'green'
+    };
+    return colorMap[riskLevel] || 'gray';
+}
+/**
+ * Génère le header de la modal
+ */
+function renderModalHeader(rule, riskColor) {
+    return `
+        <div class="sticky top-0 bg-white border-b border-gray-200 p-6 flex justify-between items-start z-10">
+            <div class="flex-1">
+                <h2 class="text-2xl font-bold text-gray-800 mb-2">${(0, shared_1.escapeHtml)(rule.summary)}</h2>
+                <div class="flex items-center space-x-2">
+                    ${(0, shared_1.renderBadge)(rule.risk_level.toUpperCase(), riskColor)}
+                    ${(0, shared_1.renderBadge)(rule.category, 'blue')}
+                    ${rule.auto_fixable ? (0, shared_1.renderBadge)('Auto-fixable', 'green') : ''}
+                </div>
+            </div>
+            <button data-modal-close class="text-gray-400 hover:text-gray-600 text-3xl font-bold leading-none">
+                ×
+            </button>
+        </div>
+    `;
+}
+/**
+ * Génère le body de la modal
+ */
+function renderModalBody(rule, matches) {
+    return `
+        <div class="p-6 space-y-6">
+            ${renderDescriptionSection(rule)}
+            ${renderCodeExamplesSection(rule)}
+            ${renderMigrationCommandSection(rule)}
+            ${renderDocumentationSection(rule)}
+            ${renderAffectedFilesSection(matches)}
+            ${renderMetadataSection(rule)}
+        </div>
+    `;
+}
+/**
+ * Section Description
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderDescriptionSection(rule) {
+    return `
+        <section>
+            <h3 class="text-lg font-bold text-gray-800 mb-2">📋 Description</h3>
+            <p class="text-gray-700 whitespace-pre-line">${(0, shared_1.escapeHtml)(rule.description)}</p>
+        </section>
+    `;
+}
+/**
+ * Section Exemples de Code
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderCodeExamplesSection(rule) {
+    if (!rule.code_description)
+        return '';
+    return `
+        <section>
+            <h3 class="text-lg font-bold text-gray-800 mb-2">💻 Exemples de Code</h3>
+            <div class="bg-gray-50 p-4 rounded-lg">
+                <pre class="text-sm text-gray-800 overflow-x-auto whitespace-pre-wrap">${(0, shared_1.escapeHtml)(rule.code_description)}</pre>
+            </div>
+        </section>
+    `;
+}
+/**
+ * Section Commande de Migration
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderMigrationCommandSection(rule) {
+    if (!rule.migration_command)
+        return '';
+    // Échapper les guillemets pour éviter les problèmes JavaScript
+    const escapedCommand = rule.migration_command.replace(/'/g, "\\'");
+    return `
+        <section>
+            <h3 class="text-lg font-bold text-gray-800 mb-2">⚡ Commande de Migration</h3>
+            <div class="flex items-center space-x-2">
+                <code class="flex-1 bg-gray-800 text-green-400 p-3 rounded-lg font-mono text-sm">${(0, shared_1.escapeHtml)(rule.migration_command)}</code>
+                <button
+                    onclick="window.copyRuleCommand(this, '${escapedCommand}')"
+                    class="px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 transition-colors"
+                    title="Copier dans le presse-papier"
+                >
+                    Copier
+                </button>
+            </div>
+        </section>
+    `;
+}
+/**
+ * Section Documentation
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderDocumentationSection(rule) {
+    if (!rule.doc_url)
+        return '';
+    return `
+        <section>
+            <h3 class="text-lg font-bold text-gray-800 mb-2">📚 Documentation</h3>
+            <a
+                href="${(0, shared_1.escapeHtml)(rule.doc_url)}"
+                target="_blank"
+                rel="noopener noreferrer"
+                class="inline-flex items-center text-blue-600 hover:text-blue-800 underline"
+            >
+                ${(0, shared_1.escapeHtml)(rule.doc_url)}
+                <svg class="w-4 h-4 ml-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
+                </svg>
+            </a>
+        </section>
+    `;
+}
+/**
+ * Section Fichiers Impactés
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderAffectedFilesSection(matches) {
+    if (matches.length === 0) {
+        return `
+            <section>
+                <h3 class="text-lg font-bold text-gray-800 mb-2">📂 Fichiers Impactés</h3>
+                <p class="text-gray-500 italic">Aucune occurrence détectée dans le projet.</p>
+            </section>
+        `;
+    }
+    return `
+        <section>
+            <h3 class="text-lg font-bold text-gray-800 mb-2">📂 Fichiers Impactés (${matches.length})</h3>
+            <div class="bg-gray-50 rounded-lg p-4 max-h-64 overflow-y-auto">
+                <ul class="space-y-2">
+                    ${matches.map(match => renderMatchItem(match)).join('')}
+                </ul>
+            </div>
+        </section>
+    `;
+}
+/**
+ * Item de match (fichier impacté)
+ */
+function renderMatchItem(match) {
+    const truncatedText = match.matchedText.substring(0, 100);
+    const displayText = match.matchedText.length > 100 ? `${truncatedText}...` : truncatedText;
+    // Formater le chemin pour VSCode (forward slashes, lowercase drive letter)
+    const vscodePath = formatVSCodePath(match.filePath);
+    return `
+        <li class="text-sm">
+            <div class="flex items-start justify-between">
+                <div class="flex-1">
+                    <code class="text-blue-600">${(0, shared_1.escapeHtml)(match.filePath)}:${match.lineNumber}</code>
+                    <p class="text-gray-600 mt-1 ml-4 text-xs font-mono bg-white p-2 rounded">${(0, shared_1.escapeHtml)(displayText)}</p>
+                </div>
+                <a
+                    href="vscode://file/${vscodePath}:${match.lineNumber}"
+                    class="px-3 py-1.5 text-xs bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors font-medium shadow-sm"
+                    title="Ouvrir dans VSCode à la ligne ${match.lineNumber}"
+                >
+                    📝 Ouvrir
+                </a>
+            </div>
+        </li>
+    `;
+}
+/**
+ * Formate un chemin Windows pour VSCode URI
+ * VSCode nécessite: forward slashes + lowercase drive letter
+ * Exemple: C:\Users\file.ts -> c:/Users/file.ts
+ */
+function formatVSCodePath(filePath) {
+    // Remplacer backslashes par forward slashes
+    let formatted = filePath.replace(/\\/g, '/');
+    // Convertir la lettre de lecteur en minuscule (C: -> c:)
+    // Format: "C:/path" ou "C:\path" -> "c:/path"
+    const driveLetterMatch = formatted.match(/^([A-Z]):/);
+    if (driveLetterMatch) {
+        formatted = driveLetterMatch[1].toLowerCase() + formatted.substring(1);
+    }
+    return formatted;
+}
+/**
+ * Section Métadonnées
+ * Exportée pour réutilisation dans guide-rule-card.template.ts
+ */
+function renderMetadataSection(rule) {
+    return `
+        <section class="border-t border-gray-200 pt-4">
+            <h3 class="text-lg font-bold text-gray-800 mb-2">🔍 Métadonnées</h3>
+            <div class="grid grid-cols-2 gap-3 text-sm">
+                <div>
+                    <span class="font-semibold text-gray-700">Clé règle :</span>
+                    <code class="ml-2 text-gray-600">${(0, shared_1.escapeHtml)(rule.key)}</code>
+                </div>
+                <div>
+                    <span class="font-semibold text-gray-700">Temps estimé :</span>
+                    <span class="ml-2 text-gray-600">${rule.estimated_time_per_occurrence} min/occurrence</span>
+                </div>
+                <div>
+                    <span class="font-semibold text-gray-700">Types fichiers :</span>
+                    <span class="ml-2 text-gray-600">${rule.fileTypes.join(', ')}</span>
+                </div>
+                <div>
+                    <span class="font-semibold text-gray-700">Auto-fixable :</span>
+                    <span class="ml-2 text-gray-600">${rule.auto_fixable ? '✅ Oui' : '❌ Non'}</span>
+                </div>
+            </div>
+        </section>
+    `;
+}
+/**
+ * Footer de la modal
+ */
+function renderModalFooter() {
+    return `
+        <div class="sticky bottom-0 bg-gray-50 border-t border-gray-200 p-4 flex justify-end">
+            <button
+                data-modal-close
+                class="px-6 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition-colors"
+            >
+                Fermer
+            </button>
+        </div>
+    `;
+}

package/dist/src/utils/core/args-parser.js

@@ -0,0 +1,123 @@
+"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.parseArgs = parseArgs;
+const path = __importStar(require("path"));
+/**
+ * Parse les arguments de la ligne de commande
+ * Supporte: --project-path=path, --scanner=ast|regex|both, --rules=[18,19,20] ou --rules=all
+ */
+function parseArgs(args) {
+    let projectPath;
+    let scannerType = 'ast'; // Défaut: AST
+    let rules = ['to18', 'to19', 'to20']; // Défaut: all
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // Support ancien format --project et nouveau --project-path
+        if (arg.startsWith('--project-path=')) {
+            projectPath = arg.substring('--project-path='.length);
+        }
+        else if (arg.startsWith('--project=')) {
+            projectPath = arg.substring('--project='.length);
+        }
+        else if ((arg === '--project-path' || arg === '--project') && i + 1 < args.length) {
+            projectPath = args[i + 1];
+            i++;
+        }
+        // Parse scanner type
+        if (arg.startsWith('--scanner=')) {
+            const value = arg.substring('--scanner='.length);
+            if (['ast', 'regex', 'both'].includes(value)) {
+                scannerType = value;
+            }
+        }
+        // Parse rules
+        if (arg.startsWith('--rules=')) {
+            const value = arg.substring('--rules='.length);
+            rules = parseRulesArgument(value);
+        }
+    }
+    if (!projectPath) {
+        projectPath = process.cwd();
+    }
+    const resolvedPath = path.isAbsolute(projectPath)
+        ? projectPath
+        : path.resolve(process.cwd(), projectPath);
+    return {
+        projectPath: resolvedPath,
+        scannerType,
+        rules
+    };
+}
+/**
+ * Parse l'argument --rules
+ * Exemples:
+ *   --rules=18          → ['to18']
+ *   --rules=[18]        → ['to18']
+ *   --rules=[18,19]     → ['to18', 'to19']
+ *   --rules=[18,19,20]  → ['to18', 'to19', 'to20']
+ *   --rules=all         → ['to18', 'to19', 'to20']
+ */
+function parseRulesArgument(value) {
+    // Cas spécial: all
+    if (value === 'all') {
+        return ['to18', 'to19', 'to20'];
+    }
+    // Nettoyer les crochets si présents
+    const cleaned = value.replace(/[\[\]]/g, '');
+    // Séparer par virgule et filtrer
+    const versions = cleaned
+        .split(',')
+        .map(v => v.trim())
+        .filter(v => v.length > 0);
+    // Convertir en MigrationVersion
+    const result = [];
+    for (const version of versions) {
+        if (version === '18') {
+            result.push('to18');
+        }
+        else if (version === '19') {
+            result.push('to19');
+        }
+        else if (version === '20') {
+            result.push('to20');
+        }
+    }
+    // Si aucune version valide, retourner all par défaut
+    if (result.length === 0) {
+        return ['to18', 'to19', 'to20'];
+    }
+    return result;
+}

package/dist/src/utils/core/array-helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = void 0;
+exports.chunk = chunk;
+/**
+ * Divise un tableau en chunks de taille fixe
+ * Utilisé pour le batch processing des fichiers AST
+ */
+function chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+// Re-export groupBy depuis shared pour rétrocompatibilité
+var array_helpers_1 = require("../shared/array-helpers");
+Object.defineProperty(exports, "groupBy", { enumerable: true, get: function () { return array_helpers_1.groupBy; } });

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findParentByTypes = findParentByTypes;
+exports.isImportOrExportSpecifier = isImportOrExportSpecifier;
+exports.extractModuleInfo = extractModuleInfo;
+exports.findImportOrExportDeclaration = findImportOrExportDeclaration;
+exports.getSpecifierName = getSpecifierName;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Trouve un nœud parent correspondant à l'un des types spécifiés
+ * Remonte dans l'arbre AST jusqu'à trouver un match ou atteindre la racine
+ *
+ * @param node - Nœud de départ
+ * @param types - Liste des types de nœuds recherchés (ex: ['ImportDeclaration', 'ExportDeclaration'])
+ * @returns Le premier parent correspondant ou undefined
+ *
+ * @example
+ * // Trouver l'ImportDeclaration parent d'un ImportSpecifier
+ * const importDecl = findParentByTypes(specifier, ['ImportDeclaration']);
+ */
+function findParentByTypes(node, types) {
+    let current = node.getParent();
+    while (current) {
+        const kindName = current.getKindName();
+        if (types.includes(kindName)) {
+            return current;
+        }
+        current = current.getParent();
+    }
+    return undefined;
+}
+/**
+ * Vérifie si un nœud est un ImportSpecifier ou ExportSpecifier
+ * Utilitaire pour éviter la répétition de cette condition
+ *
+ * @param node - Nœud à vérifier
+ * @returns true si le nœud est ImportSpecifier ou ExportSpecifier
+ */
+function isImportOrExportSpecifier(node) {
+    return ts_morph_1.Node.isImportSpecifier(node) || ts_morph_1.Node.isExportSpecifier(node);
+}
+/**
+ * Extrait les informations d'un module depuis une déclaration Import/Export
+ *
+ * @param declaration - ImportDeclaration ou ExportDeclaration
+ * @param specifier - ImportSpecifier ou ExportSpecifier
+ * @returns ModuleInfo ou undefined si extraction impossible
+ */
+function extractModuleInfo(declaration, specifier) {
+    if (!ts_morph_1.Node.isImportDeclaration(declaration) && !ts_morph_1.Node.isExportDeclaration(declaration)) {
+        return undefined;
+    }
+    const name = getSpecifierName(specifier);
+    const moduleSpecifier = declaration.getModuleSpecifierValue();
+    if (!name || !moduleSpecifier) {
+        return undefined;
+    }
+    return {
+        moduleSpecifier,
+        sourceFile: declaration.getSourceFile(),
+        name
+    };
+}
+/**
+ * Trouve le premier parent de type ImportDeclaration ou ExportDeclaration
+ * Cas d'usage spécifique pour la résolution de symboles cross-file
+ *
+ * @param node - Nœud de départ (généralement ImportSpecifier ou ExportSpecifier)
+ * @returns ImportDeclaration ou ExportDeclaration parent, ou undefined
+ */
+function findImportOrExportDeclaration(node) {
+    const parent = findParentByTypes(node, ['ImportDeclaration', 'ExportDeclaration']);
+    if (!parent) {
+        return undefined;
+    }
+    if (ts_morph_1.Node.isImportDeclaration(parent)) {
+        return parent;
+    }
+    if (ts_morph_1.Node.isExportDeclaration(parent)) {
+        return parent;
+    }
+    return undefined;
+}
+/**
+ * Obtient le nom d'un ImportSpecifier ou ExportSpecifier de manière type-safe
+ * Alternative à (node as any).getName()
+ *
+ * @param node - ImportSpecifier ou ExportSpecifier
+ * @returns Le nom du symbole ou undefined
+ */
+function getSpecifierName(node) {
+    if (ts_morph_1.Node.isImportSpecifier(node)) {
+        return node.getName();
+    }
+    if (ts_morph_1.Node.isExportSpecifier(node)) {
+        return node.getName();
+    }
+    return undefined;
+}

package/dist/src/utils/core/file-helpers.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIgnoreDir = shouldIgnoreDir;
+exports.collectFiles = collectFiles;
+exports.countFiles = countFiles;
+exports.buildBlockToRegex = buildBlockToRegex;
+/**
+ * Liste des dossiers à ignorer lors du scan de fichiers
+ */
+const IGNORED_DIRS = [
+    'node_modules',
+    'dist',
+    '.git',
+    '.angular',
+    'coverage',
+    '.nx',
+    '.idea',
+    '.vscode',
+    'tmp',
+    'temp'
+];
+/**
+ * Vérifie si un dossier doit être ignoré lors du scan
+ */
+function shouldIgnoreDir(dirName) {
+    return IGNORED_DIRS.includes(dirName);
+}
+/**
+ * Collecte récursivement les fichiers correspondant à un pattern
+ */
+function collectFiles(dirPath, pattern) {
+    const fs = require('fs');
+    const path = require('path');
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    const files = [];
+    function scanDir(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!shouldIgnoreDir(entry.name)) {
+                        scanDir(fullPath);
+                    }
+                }
+                else if (entry.isFile() && pattern.test(entry.name)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignorer les erreurs de lecture
+        }
+    }
+    scanDir(dirPath);
+    return files;
+}
+/**
+ * Compte récursivement les fichiers correspondant à un pattern
+ */
+function countFiles(dirPath, pattern) {
+    return collectFiles(dirPath, pattern).length;
+}
+/**
+ * Convertit un pattern glob (BuildBlockBlob) en RegExp
+ *
+ * @param pattern Pattern glob like "*.module.ts", "environment*.ts", "package.json"
+ * @returns RegExp pour matcher les noms de fichiers
+ */
+function buildBlockToRegex(pattern) {
+    // Échapper les caractères spéciaux regex (sauf * et /)
+    let regexStr = pattern
+        .replace(/\./g, '\\.') // . → \.
+        .replace(/\+/g, '\\+') // + → \+
+        .replace(/\?/g, '\\?') // ? → \?
+        .replace(/\^/g, '\\^') // ^ → \^
+        .replace(/\$/g, '\\$') // $ → \$
+        .replace(/\(/g, '\\(') // ( → \(
+        .replace(/\)/g, '\\)') // ) → \)
+        .replace(/\[/g, '\\[') // [ → \[
+        .replace(/\]/g, '\\]') // ] → \]
+        .replace(/\{/g, '\\{') // { → \{
+        .replace(/\}/g, '\\}') // } → \}
+        .replace(/\|/g, '\\|'); // | → \|
+    // Gérer les patterns glob
+    if (pattern.startsWith('**/')) {
+        // **/ → matcher n'importe où dans le chemin
+        regexStr = regexStr.replace(/^\*\*\//, '');
+        // * restant → .*
+        regexStr = regexStr.replace(/\*/g, '.*');
+        return new RegExp(regexStr + '$');
+    }
+    else if (pattern.startsWith('*.')) {
+        // *.ext → matcher extension à la fin
+        regexStr = regexStr.replace(/^\*/, '.*');
+        return new RegExp(regexStr + '$');
+    }
+    else if (pattern.includes('*')) {
+        // Contient * (ex: tsconfig*.json, environment*.ts)
+        regexStr = regexStr.replace(/\*/g, '.*');
+        return new RegExp('^' + regexStr + '$');
+    }
+    else {
+        // Nom exact (ex: package.json, angular.json)
+        return new RegExp('^' + regexStr + '$');
+    }
+}

package/dist/src/utils/core/html-helpers.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Helpers HTML pour génération serveur
+ * REFACTORED: Import depuis modules partagés pour éliminer la duplication (DRY)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBadge = exports.escapeJson = exports.escapeHtml = exports.formatTimeForAxis = exports.formatTime = void 0;
+exports.formatDate = formatDate;
+exports.calculateTotalTime = calculateTotalTime;
+const shared_1 = require("../shared");
+Object.defineProperty(exports, "formatTime", { enumerable: true, get: function () { return shared_1.formatTime; } });
+Object.defineProperty(exports, "formatTimeForAxis", { enumerable: true, get: function () { return shared_1.formatTimeForAxis; } });
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return shared_1.escapeHtml; } });
+Object.defineProperty(exports, "escapeJson", { enumerable: true, get: function () { return shared_1.escapeJson; } });
+Object.defineProperty(exports, "renderBadge", { enumerable: true, get: function () { return shared_1.renderBadge; } });
+/**
+ * Formate une date ISO en format lisible français (wrapper avec time)
+ */
+function formatDate(isoString) {
+    const date = new Date(isoString);
+    // Utilise formatDateShared avec format 'long-time' (custom wrapper)
+    return date.toLocaleString('fr-FR', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+}
+/**
+ * Calcule et formate le temps total pour une liste de targets
+ */
+function calculateTotalTime(targets) {
+    const totalMinutes = targets.reduce((sum, t) => sum + t.totalTime.minutes, 0);
+    return (0, shared_1.formatTime)(totalMinutes, Math.round((totalMinutes / 60) * 100) / 100, Math.round((totalMinutes / 60 / 7) * 100) / 100);
+}