@jjlmoya/utils-sports 1.1.0

package/src/tool/tournamentBracket/i18n/en.ts

@@ -0,0 +1,160 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TournamentBracketUI } from '../ui';
+
+const slug = 'tournament';
+const title = 'Free Online Bracket Generator and Tournament Organizer';
+const description = 'Organize tournaments and create single-elimination brackets for free with no registration. Perfect for FIFA, Padel, eSports and board games. 100% Mobile Friendly.';
+
+const ui: TournamentBracketUI = {
+  tournamentInProgress: 'Tournament in Progress',
+  nextMatch: 'Next Match',
+  share: 'Share',
+  backNew: 'Back / New',
+  back: 'Back',
+  newTournament: 'New Tournament',
+  setupSubtitle: 'Set up and generate your competition bracket.',
+  tournamentNameLabel: 'Tournament Name',
+  tournamentNamePlaceholder: 'E.g. Summer Tournament',
+  addPlayersLabel: 'Add Participants',
+  addPlayerPlaceholder: 'Name... or several separated by commas',
+  playersLabel: 'Players',
+  clearAll: 'Clear All',
+  emptyList: 'The list is empty',
+  howItWorks: 'How does it work?',
+  howItWorksText: 'Add participants, give it a name and generate. The system will automatically create matchups and handle "Byes" (direct passes) if there is an odd number.',
+  historyLabel: 'History',
+  noHistory: 'No tournaments saved',
+  noOldTournaments: 'No previous tournaments',
+  generateBtn: 'Generate Bracket',
+  shuffleLabel: 'Randomize matchups',
+  scoreLabel: 'Enable Scores (Optional)',
+  dragHint: 'Drag to move',
+  roundFinal: 'Final',
+  roundSemifinal: 'Semifinals',
+  roundQuarter: 'Quarterfinals',
+  roundPrefix: 'Round',
+  byeLabel: 'Bye',
+  waiting: 'Waiting...',
+  emptyRound: 'Empty round',
+  confirmClearPlayers: 'Clear the entire player list?',
+  alertMinPlayers: 'You need at least 2 players.',
+  alertLoadFailed: 'Could not load the tournament.',
+  confirmDeleteTournament: 'Permanently delete this tournament from history?',
+  toastShareLimit: 'Only tournaments with up to 32 players can be shared',
+  toastShareError: 'Error generating the link',
+  toastShareCopied: 'Link copied to clipboard',
+  toastShareFailed: 'Could not copy. URL:',
+  toastFinished: 'Tournament Finished!',
+  defaultName: 'Tournament',
+};
+
+const faqData = [
+  { question: 'How does single elimination work?', answer: 'It is a competition system where the participant who loses a match is automatically eliminated from the tournament. Winners advance to the next round (round of 16, quarterfinals, semifinals) until only two remain for the grand final.' },
+  { question: 'What happens if I have an odd number of players?', answer: 'Our tool automatically handles "BYEs". Some players will advance directly to the second round without playing in the first so the bracket always ends in powers of two (2, 4, 8, 16...).' },
+  { question: 'Can I save and share the tournament bracket?', answer: 'Yes, you can share the bracket through a unique instantly generated link. As a registration-free tool, data is kept in your browser while the tab is open.' },
+  { question: 'Does it work for eSports tournaments like FIFA or LoL?', answer: 'Absolutely. It is designed to be fast and visual, ideal for managing quick console, PC game or even board and card game tournaments.' },
+  { question: 'Is creating tournaments free?', answer: 'Yes, completely free and without restrictions. No premium plans, participant limits, watermarks or intrusive ads. Everything works offline in your browser.' },
+  { question: 'Is my data deleted if I close the browser?', answer: 'No. We use LocalStorage to automatically save all your tournaments on your device. You can close the tab, shut down the computer and come back days later: your tournament will still be there. The full history is also persistent.' },
+  { question: 'How does the "Next Match" button work?', answer: 'The system automatically detects the next ready matchup (both participants confirmed) but without a result yet. Pressing "Next Match" jumps the view directly to that match.' },
+];
+
+const howTo = [
+  { name: 'Enter participants', text: 'Write the names of the players or teams that will take part in the competition.' },
+  { name: 'Generate the bracket', text: 'Click the generate button. The system will automatically create the matchups and necessary rounds.' },
+  { name: 'Update results', text: 'Click on the winning participant of each match so they automatically advance to the next stage of the bracket.' },
+  { name: 'Finish', text: 'Once the tournament is complete, the final champion is shown.' },
+];
+
+const seo = [
+  {
+    type: 'title' as const,
+    text: 'Free Online Bracket Generator and Tournament Organizer',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Manage your sports, video game or board game competitions with the most complete, free and registration-free tournament organizer. Create visual and interactive single-elimination brackets in seconds, with an <strong>integrated scoring system</strong>, automatic history and smart match navigation. Everything works offline, directly in your browser.',
+  },
+  {
+    type: 'title' as const,
+    text: 'How to Create a Single Elimination Tournament?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: '<strong>Name your tournament</strong>, add participants (one by one or paste a comma-separated list), randomize matchups if you want, generate the bracket, manage results by tapping the winner of each match and use the "Next Match" button to navigate between unresolved matches.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Advanced Features',
+    level: 2 as const,
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Bulk entry:</strong> Add multiple participants at once separated by commas.',
+      '<strong>Exact scores:</strong> Scoring system with results like 3-1 or 21-19.',
+      '<strong>Smart navigation:</strong> "Next Match" button jumps to the next pending matchup.',
+      '<strong>Draggable bracket:</strong> Desktop view with free scroll for large tournaments.',
+      '<strong>Persistent history:</strong> All tournaments saved automatically in your browser.',
+      '<strong>Auto Walkovers:</strong> Byes and direct passes resolved without manual input.',
+      '<strong>Share by URL:</strong> Generate a compressed link to send the bracket to anyone.',
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: 'Perfect for Any Competition',
+    level: 2 as const,
+  },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Video Games & eSports',
+        description: 'Perfect for FIFA, FC25, Valorant, League of Legends, Street Fighter, Tekken, Super Smash Bros or Rocket League.',
+        icon: 'mdi:controller-classic',
+        points: ['Fast matchups', 'No team limit', 'Instantly shareable'],
+      },
+      {
+        title: 'Sports & Racket Sports',
+        description: 'Manage Padel, Tennis, Ping Pong, Badminton, Futsal or 3x3 Basketball brackets.',
+        icon: 'mdi:trophy-outline',
+        points: ['Integrated scores', 'Optimized mobile view', 'No paper needed'],
+      },
+      {
+        title: 'Board & Card Games',
+        description: 'Organize Magic: The Gathering, Pokémon TCG, Yu-Gi-Oh!, Catan, Chess or Dominoes tournaments.',
+        icon: 'mdi:cards-playing-outline',
+        points: ['Up to 64 players', 'Round history', 'Bye management'],
+      },
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: 'What are "Byes" or Direct Passes?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'In an ideal single-elimination tournament the number of participants must be a power of 2 (4, 8, 16, 32...). When you have an odd or non-power-of-2 number —for example 7, 10 or 13 players—, the system automatically assigns <strong>"Byes"</strong> in the first round. A "Bye" means a participant advances directly to the next phase without playing. Our algorithm calculates and assigns these passes fairly and automatically.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Instant, Free and No Sign-up Required',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Zero friction. No accounts, no installations, no waiting. Add participants and generate your tournament instantly. Everything is automatically saved in your browser via <strong>LocalStorage</strong>: close the tab, shut down the computer and come back days later. Your tournament and full history will still be there.',
+  },
+];
+
+const schemas: [WithContext<FAQPage>, WithContext<HowTo>, WithContext<SoftwareApplication>] = [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faqData.map((f) => ({ '@type': 'Question', name: f.question, acceptedAnswer: { '@type': 'Answer', text: f.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howTo.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })) },
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'SportsApplication', operatingSystem: 'Web', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+];
+
+export const content: ToolLocaleContent<TournamentBracketUI> = { slug, title, description, ui, seo, faqTitle: 'Frequently Asked Questions', faq: faqData, bibliography: [], howTo, schemas };

package/src/tool/tournamentBracket/i18n/es.ts

@@ -0,0 +1,178 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TournamentBracketUI } from '../ui';
+
+const slug = 'torneo';
+const title = 'Generador de Brackets y Torneos Online Gratis';
+const description = 'Organiza torneos y crea brackets de eliminación directa gratis y sin registro. Ideal para FIFA, Pádel, eSports y juegos de mesa. 100% Mobile Friendly.';
+
+const ui: TournamentBracketUI = {
+  tournamentInProgress: 'Torneo en Curso',
+  nextMatch: 'Siguiente Partido',
+  share: 'Compartir',
+  backNew: 'Volver / Nuevo',
+  back: 'Volver',
+  newTournament: 'Nuevo Torneo',
+  setupSubtitle: 'Configura y genera tu cuadro de competición.',
+  tournamentNameLabel: 'Nombre del Torneo',
+  tournamentNamePlaceholder: 'Ej. Torneo de Verano',
+  addPlayersLabel: 'Añadir Participantes',
+  addPlayerPlaceholder: 'Nombre... o varios separados por comas',
+  playersLabel: 'Jugadores',
+  clearAll: 'Borrar Todo',
+  emptyList: 'La lista está vacía',
+  howItWorks: '¿Cómo funciona?',
+  howItWorksText: 'Añade participantes, ponle nombre y genera. El sistema creará automáticamente los cruces y gestionará los "Byes" (pases directos) si son impares.',
+  historyLabel: 'Historial',
+  noHistory: 'No hay torneos guardados',
+  noOldTournaments: 'No hay torneos anteriores',
+  generateBtn: 'Generar Cuadro',
+  shuffleLabel: 'Aleatorizar emparejamientos',
+  scoreLabel: 'Activar Marcadores (Opcional)',
+  dragHint: 'Arrastra para mover',
+  roundFinal: 'Final',
+  roundSemifinal: 'Semifinales',
+  roundQuarter: 'Cuartos',
+  roundPrefix: 'Ronda',
+  byeLabel: 'Pase Directo',
+  waiting: 'Esperando...',
+  emptyRound: 'Ronda vacía',
+  confirmClearPlayers: '¿Borrar toda la lista de jugadores?',
+  alertMinPlayers: 'Necesitas al menos 2 jugadores.',
+  alertLoadFailed: 'No se pudo cargar el torneo.',
+  confirmDeleteTournament: '¿Borrar este torneo del historial permanentemente?',
+  toastShareLimit: 'Solo se pueden compartir torneos de hasta 32 jugadores',
+  toastShareError: 'Error al generar el enlace',
+  toastShareCopied: 'Enlace copiado al portapapeles',
+  toastShareFailed: 'No se pudo copiar. URL:',
+  toastFinished: '¡Torneo Finalizado!',
+  defaultName: 'Torneo',
+};
+
+const faqData = [
+  { question: '¿Cómo funciona la eliminación directa?', answer: 'Es un sistema de competición donde el participante que pierde un encuentro queda automáticamente eliminado del torneo. Los ganadores avanzan a la siguiente ronda (octavos, cuartos, semifinal) hasta que solo quedan dos para la gran final.' },
+  { question: '¿Qué pasa si tengo un número impar de jugadores?', answer: 'Nuestra herramienta gestiona automáticamente los "BYEs". Algunos jugadores pasarán directamente a la segunda ronda sin jugar en la primera para que el cuadro siempre acabe en potencias de dos (2, 4, 8, 16...).' },
+  { question: '¿Puedo guardar y compartir el cuadro del torneo?', answer: 'Sí, puedes compartir el bracket mediante un enlace único generado al instante. Al ser una herramienta sin registro, los datos se mantienen en tu navegador mientras la pestaña esté abierta.' },
+  { question: '¿Sirve para torneos de eSports como FIFA o LoL?', answer: 'Totalmente. Está diseñado para ser rápido y visual, ideal para gestionar torneos rápidos de consola, juegos de PC o incluso competiciones de juegos de mesa y cartas.' },
+  { question: '¿Es gratis crear torneos?', answer: 'Sí, completamente gratuito y sin restricciones. No hay planes premium, límites de participantes, marcas de agua, ni anuncios intrusivos. Todo funciona offline en tu navegador.' },
+  { question: '¿Se borran mis datos si cierro el navegador?', answer: 'No. Utilizamos LocalStorage para guardar todos tus torneos automáticamente en tu dispositivo. Puedes cerrar la pestaña, apagar el ordenador y volver días después: tu torneo seguirá ahí. El historial completo también se mantiene persistente.' },
+  { question: '¿Cómo funciona el botón "Siguiente Partido"?', answer: 'El sistema detecta automáticamente el próximo enfrentamiento que está listo para jugarse (ambos participantes confirmados) pero aún sin resultado. Al pulsar "Siguiente Partido", la vista salta directamente a ese match.' },
+];
+
+const howTo = [
+  { name: 'Introducir participantes', text: 'Escribe los nombres de los jugadores o equipos que van a participar en la competición.' },
+  { name: 'Generar el cuadro', text: 'Pulsa el botón de generar. El sistema creará automáticamente los enfrentamientos y las rondas necesarias.' },
+  { name: 'Actualizar resultados', text: 'Haz clic en los participantes ganadores de cada partido para que avancen automáticamente a la siguiente fase del bracket.' },
+  { name: 'Descargar y finalizar', text: 'Una vez completado el torneo, descarga el resultado final para guardar el recuerdo de la victoria.' },
+];
+
+const seo = [
+  {
+    type: 'title' as const,
+    text: 'Generador de Brackets y Organizador de Torneos Online',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Gestiona tus competiciones deportivas, de videojuegos o de mesa con el organizador de torneos más completo, gratuito y sin registro. Crea cuadros de eliminatoria directa (brackets) visuales e interactivos en segundos, con <strong>sistema de puntuación integrado</strong>, historial automático y navegación inteligente entre partidos. Todo funciona offline, directamente en tu navegador.',
+  },
+  {
+    type: 'title' as const,
+    text: '¿Cómo crear un Torneo de Eliminación Directa?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Organizar una competición profesional nunca ha sido tan sencillo. <strong>Nombra tu torneo</strong>, añade participantes (uno a uno o pegando una lista separada por comas), aleatoriza los cruces si quieres, genera el bracket, gestiona los resultados tocando al ganador de cada encuentro y usa el botón "Siguiente Partido" para navegar entre partidos sin resolver.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Funcionalidades Avanzadas',
+    level: 2 as const,
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Entrada masiva:</strong> Añade varios participantes a la vez separados por comas.',
+      '<strong>Marcadores exactos:</strong> Sistema de puntuación con scores tipo 3-1 ó 21-19.',
+      '<strong>Navegación inteligente:</strong> Botón "Siguiente Partido" que salta al próximo encuentro pendiente.',
+      '<strong>Bracket arrastrable:</strong> Vista de escritorio con scroll libre para torneos grandes.',
+      '<strong>Historial persistente:</strong> Todos los torneos se guardan en tu navegador automáticamente.',
+      '<strong>Walkovers automáticos:</strong> Resolución de pases directos y Byes sin intervención manual.',
+      '<strong>Compartir por URL:</strong> Genera un enlace comprimido para enviar el bracket a cualquiera.',
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: 'Ideal para cualquier tipo de competición',
+    level: 2 as const,
+  },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Videojuegos y eSports',
+        description: 'Perfecto para FIFA, FC25, Valorant, League of Legends, Street Fighter, Tekken, Super Smash Bros o Rocket League.',
+        icon: 'mdi:controller-classic',
+        points: ['Partidas rápidas', 'Sin límite de equipos', 'Compartible al instante'],
+      },
+      {
+        title: 'Deportes y Pistas',
+        description: 'Gestiona cuadros de Pádel, Tenis, Ping Pong, Bádminton, Fútbol Sala o Baloncesto 3x3.',
+        icon: 'mdi:trophy-outline',
+        points: ['Marcadores integrados', 'Vista móvil optimizada', 'Sin papel ni pizarra'],
+      },
+      {
+        title: 'Juegos de Mesa y Cartas',
+        description: 'Organiza partidas de Magic: The Gathering, Pokémon TCG, Yu-Gi-Oh!, Catan, Ajedrez o Dominó.',
+        icon: 'mdi:cards-playing-outline',
+        points: ['Hasta 64 jugadores', 'Historial de rondas', 'Gestión de Byes'],
+      },
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: '¿Qué son los "Byes" o Pases Directos?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'En un torneo de eliminación directa ideal, el número de participantes debe ser una potencia de 2 (4, 8, 16, 32...). Cuando tienes un número impar o no potencia de 2 —por ejemplo 7, 10 o 13 jugadores—, el sistema asigna automáticamente <strong>"Byes"</strong> en la primera ronda. Un "Bye" significa que un participante pasa directamente a la siguiente fase sin jugar. Nuestro algoritmo calcula y asigna estos pases de forma justa y automática.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Instantáneo, Gratuito y Sin Registro',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Cero fricción. Sin cuentas, sin instalaciones, sin esperas. Añade participantes y genera tu torneo al instante. Todo se guarda automáticamente en tu navegador con <strong>LocalStorage</strong>: puedes cerrar la pestaña, apagar el ordenador y volver días después. Tu torneo y el historial completo seguirán ahí.',
+  },
+];
+
+const schemas: [WithContext<FAQPage>, WithContext<HowTo>, WithContext<SoftwareApplication>] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqData.map((f) => ({ '@type': 'Question', name: f.question, acceptedAnswer: { '@type': 'Answer', text: f.answer } })),
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    description,
+    step: howTo.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'SportsApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  },
+];
+
+export const content: ToolLocaleContent<TournamentBracketUI> = { slug, title, description, ui, seo, faqTitle: 'Preguntas frecuentes', faq: faqData, bibliography: [], howTo, schemas };

package/src/tool/tournamentBracket/i18n/fr.ts

@@ -0,0 +1,160 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TournamentBracketUI } from '../ui';
+
+const slug = 'tournoi';
+const title = 'Générateur de Brackets et Organisateur de Tournois Gratuit';
+const description = 'Organisez des tournois et créez des brackets à élimination directe gratuitement et sans inscription. Idéal pour FIFA, Padel, eSports et jeux de société. 100% Mobile Friendly.';
+
+const ui: TournamentBracketUI = {
+  tournamentInProgress: 'Tournoi en cours',
+  nextMatch: 'Match suivant',
+  share: 'Partager',
+  backNew: 'Retour / Nouveau',
+  back: 'Retour',
+  newTournament: 'Nouveau tournoi',
+  setupSubtitle: 'Configurez et générez votre tableau de compétition.',
+  tournamentNameLabel: 'Nom du tournoi',
+  tournamentNamePlaceholder: 'Ex. Tournoi d\'été',
+  addPlayersLabel: 'Ajouter des participants',
+  addPlayerPlaceholder: 'Nom... ou plusieurs séparés par des virgules',
+  playersLabel: 'Joueurs',
+  clearAll: 'Tout effacer',
+  emptyList: 'La liste est vide',
+  howItWorks: 'Comment ça marche ?',
+  howItWorksText: 'Ajoutez des participants, donnez un nom et générez. Le système créera automatiquement les confrontations et gérera les "Byes" (passages directs) si le nombre est impair.',
+  historyLabel: 'Historique',
+  noHistory: 'Aucun tournoi sauvegardé',
+  noOldTournaments: 'Aucun tournoi précédent',
+  generateBtn: 'Générer le tableau',
+  shuffleLabel: 'Mélanger les confrontations',
+  scoreLabel: 'Activer les scores (Optionnel)',
+  dragHint: 'Glisser pour déplacer',
+  roundFinal: 'Finale',
+  roundSemifinal: 'Demi-finales',
+  roundQuarter: 'Quarts de finale',
+  roundPrefix: 'Tour',
+  byeLabel: 'Passage direct',
+  waiting: 'En attente...',
+  emptyRound: 'Tour vide',
+  confirmClearPlayers: 'Effacer toute la liste des joueurs ?',
+  alertMinPlayers: 'Vous avez besoin d\'au moins 2 joueurs.',
+  alertLoadFailed: 'Impossible de charger le tournoi.',
+  confirmDeleteTournament: 'Supprimer définitivement ce tournoi de l\'historique ?',
+  toastShareLimit: 'Seuls les tournois de 32 joueurs maximum peuvent être partagés',
+  toastShareError: 'Erreur lors de la génération du lien',
+  toastShareCopied: 'Lien copié dans le presse-papiers',
+  toastShareFailed: 'Impossible de copier. URL :',
+  toastFinished: 'Tournoi terminé !',
+  defaultName: 'Tournoi',
+};
+
+const faqData = [
+  { question: 'Comment fonctionne l\'élimination directe ?', answer: 'C\'est un système de compétition où le participant qui perd un match est automatiquement éliminé du tournoi. Les gagnants avancent au tour suivant (huitièmes, quarts, demi-finales) jusqu\'à ce qu\'il n\'en reste que deux pour la grande finale.' },
+  { question: 'Que se passe-t-il si j\'ai un nombre impair de joueurs ?', answer: 'Notre outil gère automatiquement les "BYEs". Certains joueurs passeront directement au deuxième tour sans jouer au premier pour que le tableau se termine toujours en puissances de deux (2, 4, 8, 16...).' },
+  { question: 'Puis-je sauvegarder et partager le tableau du tournoi ?', answer: 'Oui, vous pouvez partager le bracket via un lien unique généré instantanément. En tant qu\'outil sans inscription, les données sont conservées dans votre navigateur tant que l\'onglet est ouvert.' },
+  { question: 'Ça marche pour des tournois eSports comme FIFA ou LoL ?', answer: 'Absolument. Il est conçu pour être rapide et visuel, idéal pour gérer des tournois rapides de console, jeux PC ou même des compétitions de jeux de société et de cartes.' },
+  { question: 'La création de tournois est-elle gratuite ?', answer: 'Oui, complètement gratuit et sans restrictions. Pas de plans premium, de limites de participants, de filigranes, ni de publicités intrusives. Tout fonctionne hors ligne dans votre navigateur.' },
+  { question: 'Mes données sont-elles supprimées si je ferme le navigateur ?', answer: 'Non. Nous utilisons le LocalStorage pour sauvegarder automatiquement tous vos tournois sur votre appareil. Vous pouvez fermer l\'onglet, éteindre l\'ordinateur et revenir des jours plus tard : votre tournoi sera toujours là.' },
+  { question: 'Comment fonctionne le bouton "Match suivant" ?', answer: 'Le système détecte automatiquement la prochaine confrontation prête à être jouée (les deux participants confirmés) mais sans résultat. En appuyant sur "Match suivant", la vue saute directement à ce match.' },
+];
+
+const howTo = [
+  { name: 'Saisir les participants', text: 'Écrivez les noms des joueurs ou équipes qui vont participer à la compétition.' },
+  { name: 'Générer le tableau', text: 'Cliquez sur le bouton générer. Le système créera automatiquement les confrontations et les tours nécessaires.' },
+  { name: 'Mettre à jour les résultats', text: 'Cliquez sur le participant gagnant de chaque match pour qu\'il avance automatiquement à la phase suivante du bracket.' },
+  { name: 'Terminer', text: 'Une fois le tournoi terminé, le champion final est affiché.' },
+];
+
+const seo = [
+  {
+    type: 'title' as const,
+    text: 'Générateur de Brackets et Organisateur de Tournois en Ligne',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Gérez vos compétitions sportives, de jeux vidéo ou de société avec l\'organisateur de tournois le plus complet, gratuit et sans inscription. Créez des tableaux d\'élimination directe visuels et interactifs en quelques secondes, avec un <strong>système de score intégré</strong>, un historique automatique et une navigation intelligente entre les matchs. Tout fonctionne hors ligne, directement dans votre navigateur.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Comment créer un tournoi à élimination directe ?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: '<strong>Nommez votre tournoi</strong>, ajoutez des participants (un par un ou en collant une liste séparée par des virgules), mélangez si vous voulez, générez le tableau, gérez les résultats en appuyant sur le gagnant de chaque match et utilisez le bouton "Match suivant" pour naviguer entre les matchs non résolus.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Fonctionnalités Avancées',
+    level: 2 as const,
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Saisie massive :</strong> Ajoutez plusieurs participants à la fois séparés par des virgules.',
+      '<strong>Scores exacts :</strong> Système de score avec résultats type 3-1 ou 21-19.',
+      '<strong>Navigation intelligente :</strong> Le bouton "Match suivant" saute au prochain match en attente.',
+      '<strong>Bracket déplaçable :</strong> Vue bureau avec défilement libre pour les grands tournois.',
+      '<strong>Historique persistant :</strong> Tous les tournois sauvegardés automatiquement dans votre navigateur.',
+      '<strong>Walkovers automatiques :</strong> Byes et passages directs résolus sans intervention manuelle.',
+      '<strong>Partage par URL :</strong> Générez un lien compressé pour envoyer le bracket à tout le monde.',
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: 'Idéal pour tout type de compétition',
+    level: 2 as const,
+  },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Jeux vidéo & eSports',
+        description: 'Parfait pour FIFA, FC25, Valorant, League of Legends, Street Fighter, Tekken ou Rocket League.',
+        icon: 'mdi:controller-classic',
+        points: ['Matchs rapides', 'Sans limite d\'équipes', 'Partageable instantanément'],
+      },
+      {
+        title: 'Sports & Raquettes',
+        description: 'Gérez des tableaux de Padel, Tennis, Ping Pong, Badminton, Futsal ou Basket 3x3.',
+        icon: 'mdi:trophy-outline',
+        points: ['Scores intégrés', 'Vue mobile optimisée', 'Sans papier ni tableau'],
+      },
+      {
+        title: 'Jeux de société & Cartes',
+        description: 'Organisez des parties de Magic, Pokémon TCG, Yu-Gi-Oh!, Catan, Échecs ou Dominos.',
+        icon: 'mdi:cards-playing-outline',
+        points: ['Jusqu\'à 64 joueurs', 'Historique des tours', 'Gestion des Byes'],
+      },
+    ],
+  },
+  {
+    type: 'title' as const,
+    text: 'Que sont les "Byes" ou passages directs ?',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Dans un tournoi à élimination directe idéal, le nombre de participants doit être une puissance de 2 (4, 8, 16, 32...). Quand vous avez un nombre impair ou non puissance de 2 —par exemple 7, 10 ou 13 joueurs—, le système assigne automatiquement des <strong>"Byes"</strong> au premier tour. Un "Bye" signifie qu\'un participant passe directement à la phase suivante sans jouer. Notre algorithme calcule et assigne ces passages de façon juste et automatique.',
+  },
+  {
+    type: 'title' as const,
+    text: 'Instantané, Gratuit et Sans Inscription',
+    level: 2 as const,
+  },
+  {
+    type: 'paragraph' as const,
+    html: 'Zéro friction. Sans comptes, sans installations, sans attente. Ajoutez des participants et générez votre tournoi instantanément. Tout est sauvegardé automatiquement dans votre navigateur via <strong>LocalStorage</strong> : fermez l\'onglet, éteignez l\'ordinateur et revenez des jours plus tard. Votre tournoi et l\'historique complet seront toujours là.',
+  },
+];
+
+const schemas: [WithContext<FAQPage>, WithContext<HowTo>, WithContext<SoftwareApplication>] = [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faqData.map((f) => ({ '@type': 'Question', name: f.question, acceptedAnswer: { '@type': 'Answer', text: f.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howTo.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })) },
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'SportsApplication', operatingSystem: 'Web', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+];
+
+export const content: ToolLocaleContent<TournamentBracketUI> = { slug, title, description, ui, seo, faqTitle: 'Questions fréquentes', faq: faqData, bibliography: [], howTo, schemas };

package/src/tool/tournamentBracket/index.ts

@@ -0,0 +1,34 @@
+import type { SportsToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import TournamentBracketComponent from './component.astro';
+import TournamentBracketSEO from './seo.astro';
+import TournamentBracketBibliography from './bibliography.astro';
+import type { TournamentBracketUI } from './ui';
+
+export type { TournamentBracketUI };
+export type TournamentBracketLocaleContent = ToolLocaleContent<TournamentBracketUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const tournamentBracket: SportsToolEntry<TournamentBracketUI> = {
+  id: 'tournament-bracket',
+  icons: {
+    bg: 'mdi:sitemap',
+    fg: 'mdi:trophy',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { TournamentBracketComponent, TournamentBracketSEO, TournamentBracketBibliography };
+
+export const TOURNAMENT_BRACKET_TOOL: ToolDefinition = {
+  entry: tournamentBracket,
+  Component: TournamentBracketComponent,
+  SEOComponent: TournamentBracketSEO,
+  BibliographyComponent: TournamentBracketBibliography,
+};

package/src/tool/tournamentBracket/logic/active.controller.ts

@@ -0,0 +1,106 @@
+import type { TournamentUIMediator } from '../ui/mediator';
+import type { TournamentRenderer } from '../tournament.renderer';
+import type { TournamentBracketUI } from '../ui';
+import type { TournamentManager } from './manager';
+import { TournamentStorage } from './storage';
+import { TournamentNavigator } from '../ui/navigator';
+import { TournamentSharing } from './sharing';
+
+export class ActiveController {
+  private activeRoundMobile = 0;
+  private manager: TournamentManager | null = null;
+
+  constructor(
+    private mediator: TournamentUIMediator,
+    private renderer: TournamentRenderer,
+    private ui: TournamentBracketUI
+  ) {
+    this.bindEvents();
+  }
+
+  public setManager(manager: TournamentManager) { this.manager = manager; this.activeRoundMobile = 0; }
+
+  private bindEvents() {
+    this.mediator.btnNextMatch?.addEventListener('click', () => this.scrollToNextMatch());
+    this.mediator.enableTitleEditing((name) => {
+      if (this.manager && name !== this.manager.name) { this.manager.name = name; this.saveCurrentState(); }
+      this.render();
+    });
+    document.getElementById('share-tournament-btn')?.addEventListener('click', () => { void this.shareTournament(); });
+  }
+
+  public render() {
+    if (!this.manager) return;
+    this.mediator.updateHeader(this.manager.name, new Date(this.manager.createdAt).toLocaleDateString());
+    this.renderer.renderMobileView(this.manager, this.activeRoundMobile, (i) => { this.activeRoundMobile = i; this.render(); });
+    this.renderer.renderDesktopView(this.manager);
+    this.attachMatchListeners();
+  }
+
+  private attachMatchListeners() {
+    document.querySelectorAll('.tb-match-btn').forEach((btn) => {
+      btn.addEventListener('click', (e) => {
+        const t = e.currentTarget as HTMLElement;
+        if (!t.hasAttribute('disabled')) this.selectWinner(t.dataset.matchId!, t.dataset.winnerId!);
+      });
+    });
+    document.querySelectorAll('.tb-score-input').forEach((input) => {
+      input.addEventListener('change', (e) => {
+        const t = e.target as HTMLInputElement;
+        if (t.dataset.matchId && t.dataset.player) this.updateScore(t.dataset.matchId, t.dataset.player, t.value);
+      });
+      input.addEventListener('click', (e) => e.stopPropagation());
+    });
+  }
+
+  private parseScore(value: string): number | null {
+    if (value.trim() === '') return null;
+    const n = parseInt(value);
+    return isNaN(n) ? null : n;
+  }
+
+  private updateScore(matchId: string, playerNum: string, value: string) {
+    if (!this.manager) return;
+    const match = this.manager.findMatch(matchId);
+    if (!match) return;
+    const val = this.parseScore(value);
+    const s1 = playerNum === '1' ? val : (match.score1 ?? null);
+    const s2 = playerNum === '2' ? val : (match.score2 ?? null);
+    this.manager.setScore(matchId, s1, s2);
+    this.saveCurrentState();
+    this.render();
+    if (this.manager.status === 'FINISHED') this.mediator.showVictoryToast();
+  }
+
+  private selectWinner(matchId: string, winnerId: string) {
+    if (!this.manager) return;
+    this.manager.setWinner(matchId, winnerId);
+    this.saveCurrentState();
+    this.render();
+    if (this.manager.status === 'FINISHED') this.mediator.showVictoryToast();
+  }
+
+  private saveCurrentState() {
+    if (!this.manager) return;
+    TournamentStorage.saveTournament(this.manager, TournamentStorage.loadHistory());
+  }
+
+  private scrollToNextMatch() {
+    if (!this.manager) return;
+    const next = TournamentNavigator.findNextPlayableMatch(this.manager);
+    if (!next) { if (!TournamentNavigator.isTournamentUnfinished(this.manager)) this.mediator.showVictoryToast(); return; }
+    TournamentNavigator.scrollToMatch(next.id, this.manager, this.activeRoundMobile, {
+      onMobileRoundChange: (i) => { this.activeRoundMobile = i; this.render(); },
+      onShowToast: () => this.mediator.showVictoryToast(),
+    });
+  }
+
+  private async shareTournament() {
+    if (!this.manager) return;
+    if (!TournamentSharing.canShare(this.manager)) { this.mediator.showToast(this.ui.toastShareLimit, 'error'); return; }
+    const url = TournamentSharing.generateShareUrl(this.manager);
+    if (!url) { this.mediator.showToast(this.ui.toastShareError, 'error'); return; }
+    const ok = await TournamentSharing.copyToClipboard(url);
+    this.mediator.showToast(ok ? this.ui.toastShareCopied : `${this.ui.toastShareFailed} ${url}`, ok ? 'success' : 'error');
+  }
+}