@jjlmoya/utils-sports 1.1.0

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

@@ -0,0 +1,144 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { ReactionTesterUI } from '../ui';
+
+const slug = 'reaction-test';
+const title = 'Reaction Speed Test (Reflexes): Online Benchmark';
+const description = 'Measure your reflexes in milliseconds with our professional reaction test. Compete for ranks from \'Turtle\' to \'Cyberathlete\' and analyze your performance.';
+
+const ui: ReactionTesterUI = {
+  title: 'Reaction Test',
+  subtitle: 'Measure your reaction speed in milliseconds. Average of 5 attempts.',
+  startBtn: 'Click to start',
+  goTitle: 'GO!',
+  goSubtitle: 'HIT IT NOW!',
+  earlyTitle: 'Too soon!',
+  earlySubtitle: 'Wait for the green.',
+  earlyRetry: 'Click to retry',
+  promptNext: 'Click for attempt',
+  promptFinal: 'See Final Results',
+  avgLabel: 'Final average',
+  copyBtn: 'Copy',
+  tweetBtn: 'Tweet',
+  retryBtn: 'Try again',
+  inputMouse: 'Mouse',
+  inputTouch: 'Touch',
+  inputSpace: 'Space',
+  historyTitle: 'Local History',
+  historyBest: 'Top 5 Best',
+  historyWorst: 'Top 5 Worst',
+  historyEmpty: 'Play to record your first score',
+  copySuccess: 'Copied!',
+  shareText: 'I scored {ms}ms on the Reaction Test!\nRank: {rank}\n\nCan you beat me?\n{url}',
+  rankCiberatleta: 'Cyberathlete',
+  rankTigre: 'Tiger',
+  rankHumano: 'Human',
+  rankTortuga: 'Turtle',
+  rankDormido: 'Asleep',
+  f150: 'ARE YOU A ROBOT?!',
+  f180: 'INCREDIBLE!',
+  f210: 'Very fast!',
+  f250: 'Good reaction',
+  f300: 'Not bad...',
+  f400: 'A bit slow...',
+  f600: 'You fell asleep',
+  fSlow: 'Wake up...',
+  wp0t: 'WAIT...', wp0s: 'Hold your breath...',
+  wp1t: 'STILL...', wp1s: 'Don\'t blink now',
+  wp2t: 'READY...', wp2s: 'Fingers ready...',
+  wp3t: 'HOLD...', wp3s: 'Patience, grasshopper',
+  wp4t: 'FOCUS...', wp4s: 'It\'s coming...',
+};
+
+const faqData = [
+  { question: 'What is the average human reaction time?', answer: 'The average human reaction time to a visual stimulus is approximately 250 to 270 milliseconds. High-performance athletes and pro-gamers are usually below 200ms.' },
+  { question: 'How can I improve my reflexes?', answer: 'The key is consistent practice and rest. Playing action video games (FPS), practicing fast sports like ping-pong and staying well hydrated helps keep the nervous system alert.' },
+  { question: 'Does the screen affect my result?', answer: 'Yes. There is something called \'input lag\'. Screens with a low refresh rate (60Hz) or old wireless mice can add 15 to 50ms to your actual reaction time.' },
+  { question: 'At what age do we start losing reflexes?', answer: 'Physiologically, human reflexes peak between ages 20 and 24. After that, there is a very slow decline (approx. 2-6ms per decade) if not trained.' },
+];
+
+const howTo = [
+  { name: 'Wait for red', text: 'Click the start area and wait patiently for the screen to change color.' },
+  { name: 'React to green', text: 'As soon as you see green, click or tap the screen as fast as you can.' },
+  { name: 'See your result', text: 'The system will calculate the exact difference in milliseconds between the color change and your tap.' },
+  { name: 'Analyze your rank', text: 'Repeat the test 5 times to get a reliable average and find out if you are a \'Turtle\' or a \'Cyberathlete\'.' },
+];
+
+const seo = [
+  { type: 'title' as const, text: 'How Does This Reaction Test Work?', level: 2 as const },
+  {
+    type: 'paragraph' as const,
+    html: 'This tool measures your <strong>visual reaction time</strong> with surgical precision. We calculate the exact interval from when the screen lights up until the signal travels from your eyes to your brain, and then to your fingers. The test requires <strong>5 consecutive attempts</strong> to calculate your real average, eliminating the luck factor.',
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Average of 5 attempts:</strong> We eliminate the "luck" factor by requiring consistency. A single lucky click won\'t make you a Cyberathlete.',
+      '<strong>Anti-Cheat System:</strong> Random wait times (1.5s - 4.5s) and early-click detection to prevent prediction.',
+      '<strong>Real science:</strong> Brain processing ~180-200ms + motor response +20-40ms = your total reaction time.',
+    ],
+  },
+  { type: 'title' as const, text: 'World Ranking Table', level: 2 as const },
+  {
+    type: 'table' as const,
+    headers: ['Time', 'Rank', 'Description'],
+    rows: [
+      ['&lt; 180 ms', 'Cyberathlete', 'Superhuman level typical of eSports pros or fighter pilots.'],
+      ['180 - 230 ms', 'Tiger', 'Sharp reflexes. You\'re probably great at shooters.'],
+      ['230 - 280 ms', 'Human', 'The healthy average. You\'re awake and functioning properly.'],
+      ['280 - 350 ms', 'Turtle', 'Below average. Rest or train more.'],
+      ['&gt; 350 ms', 'Asleep', 'Possible fatigue, sleepiness or slow hardware (input lag).'],
+    ],
+  },
+  { type: 'title' as const, text: 'Why Are You Slow? Blaming the Hardware', level: 2 as const },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Monitor (Hz)',
+        description: 'A 60Hz monitor takes ~16ms to paint a frame. A 144Hz one takes only 7ms. That 10ms difference counts in your final score.',
+        icon: 'mdi:monitor',
+        points: ['60Hz = ~16ms per frame', '144Hz = ~7ms per frame', 'Visible difference in test'],
+      },
+      {
+        title: 'Wireless Mouse',
+        description: 'Cheap office Bluetooth mice have high latency. For this test, use a cable or low-latency 2.4GHz wireless technology.',
+        icon: 'mdi:mouse-variant',
+        points: ['Cheap Bluetooth: +15-50ms', '2.4GHz gaming: <1ms extra', 'USB cable: reference'],
+      },
+      {
+        title: 'Browser',
+        description: 'Extensions that block ads or heavy scripts can cause stuttering. Try incognito mode for your real record.',
+        icon: 'mdi:web',
+        points: ['Close heavy extensions', 'Incognito = cleaner', 'Chrome/Firefox recommended'],
+      },
+    ],
+  },
+];
+
+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<ReactionTesterUI> = { slug, title, description, ui, seo, faqTitle: 'Frequently Asked Questions', faq: faqData, bibliography: [], howTo, schemas };

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

@@ -0,0 +1,144 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { ReactionTesterUI } from '../ui';
+
+const slug = 'test-reflejos';
+const title = 'Test de Velocidad de Reacción (Reflejos): Benchmark Online';
+const description = 'Mide tus reflejos en milisegundos con nuestro test de reacción profesional. Compite por rangos desde \'Tortuga\' hasta \'Ciberatleta\' y analiza tu rendimiento.';
+
+const ui: ReactionTesterUI = {
+  title: 'Test de Reflejos',
+  subtitle: 'Mide tu velocidad de reacción en milisegundos. Promedio de 5 intentos.',
+  startBtn: 'Haz click para comenzar',
+  goTitle: '¡YA!',
+  goSubtitle: '¡DALE AHORA!',
+  earlyTitle: '¡Demasiado pronto!',
+  earlySubtitle: 'Espera a que se ponga verde.',
+  earlyRetry: 'Click para reintentar',
+  promptNext: 'Click para intento',
+  promptFinal: 'Ver Resultados Finales',
+  avgLabel: 'Promedio final',
+  copyBtn: 'Copiar',
+  tweetBtn: 'Twittear',
+  retryBtn: 'Intentar de nuevo',
+  inputMouse: 'Ratón',
+  inputTouch: 'Táctil',
+  inputSpace: 'Espacio',
+  historyTitle: 'Historial Local',
+  historyBest: 'Top 5 Mejores',
+  historyWorst: 'Top 5 Peores',
+  historyEmpty: 'Juega para registrar tu primer récord',
+  copySuccess: '¡Copiado!',
+  shareText: '¡He sacado {ms}ms en el Test de Reflejos!\nRango: {rank}\n\n¿Puedes superarme?\n{url}',
+  rankCiberatleta: 'Ciberatleta',
+  rankTigre: 'Tigre',
+  rankHumano: 'Humano',
+  rankTortuga: 'Tortuga',
+  rankDormido: 'Dormido',
+  f150: '¡¿ERES UN ROBOT?!',
+  f180: '¡INCREÍBLE!',
+  f210: '¡Muy rápido!',
+  f250: 'Buena reacción',
+  f300: 'No está mal...',
+  f400: 'Un poco lento...',
+  f600: 'Te has dormido',
+  fSlow: 'Despierta...',
+  wp0t: 'ESPERA...', wp0s: 'Aguanta la respiración...',
+  wp1t: 'QUIETO...', wp1s: 'No parpadees ahora',
+  wp2t: 'ATENTO...', wp2s: 'Dedos preparados...',
+  wp3t: 'HOLD...', wp3s: 'Paciencia, saltamontes',
+  wp4t: 'OJITO...', wp4s: 'Va a salir ya...',
+};
+
+const faqData = [
+  { question: '¿Cuál es el tiempo de reacción medio de un humano?', answer: 'El tiempo medio de reacción humana ante un estímulo visual es de aproximadamente 250 a 270 milisegundos. Los atletas de alto rendimiento y pro-gamers suelen estar por debajo de los 200ms.' },
+  { question: '¿Cómo puedo mejorar mis reflejos?', answer: 'La clave es la práctica constante y el descanso. Jugar a videojuegos de acción (FPS), practicar deportes rápidos como el ping-pong y mantener una buena hidratación ayuda a mantener el sistema nervioso alerta.' },
+  { question: '¿Afecta la pantalla a mi resultado?', answer: 'Sí. Existe algo llamado \'input lag\'. Las pantallas con baja tasa de refresco (60Hz) o los ratones inalámbricos antiguos pueden añadir entre 15 y 50ms extras a tu tiempo real de reacción.' },
+  { question: '¿A qué edad empezamos a perder reflejos?', answer: 'Fisiológicamente, los reflejos humanos alcanzan su pico máximo entre los 20 y 24 años. A partir de ahí, se produce un declive muy lento (aprox. 2-6ms por década) si no se entrenan.' },
+];
+
+const howTo = [
+  { name: 'Esperar al color rojo', text: 'Haz clic en la zona de inicio y espera pacientemente a que la pantalla cambie de color.' },
+  { name: 'Reaccionar al verde', text: 'En cuanto veas el color verde, haz clic o toca la pantalla lo más rápido que puedas.' },
+  { name: 'Ver el resultado', text: 'El sistema calculará la diferencia exacta en milisegundos entre el cambio de color y tu pulsación.' },
+  { name: 'Analizar tu rango', text: 'Repite el test 5 veces para obtener una media fiable y descubrir si eres una \'Tortuga\' o un \'Ciberatleta\'.' },
+];
+
+const seo = [
+  { type: 'title' as const, text: '¿Cómo funciona este Test de Reflejos?', level: 2 as const },
+  {
+    type: 'paragraph' as const,
+    html: 'Esta herramienta mide tu <strong>tiempo de reacción visual</strong> con precisión quirúrgica. Calculamos el intervalo exacto desde que la pantalla se ilumina hasta que la señal viaja de tus ojos al cerebro, y de ahí a tus dedos. El test exige <strong>5 intentos consecutivos</strong> para calcular tu promedio real, eliminando el factor suerte.',
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Promedio de 5 intentos:</strong> Eliminamos el factor "suerte" obligándote a ser consistente. Un solo clic afortunado no te hará un Ciberatleta.',
+      '<strong>Sistema Anti-Trampas:</strong> Tiempos de espera aleatorios (1.5s - 4.5s) y detección de clics anticipados para evitar predicciones.',
+      '<strong>Ciencia real:</strong> Procesamiento cerebral ~180-200ms + respuesta motora +20-40ms = tu tiempo total de reacción.',
+    ],
+  },
+  { type: 'title' as const, text: 'Tabla de Clasificación Mundial', level: 2 as const },
+  {
+    type: 'table' as const,
+    headers: ['Tiempo', 'Rango', 'Descripción'],
+    rows: [
+      ['&lt; 180 ms', 'Ciberatleta', 'Nivel sobrehumano propio de pros de eSports o pilotos de caza.'],
+      ['180 - 230 ms', 'Tigre', 'Reflejos afilados. Probablemente seas muy bueno en shooters.'],
+      ['230 - 280 ms', 'Humano', 'El promedio saludable. Estás despierto y funcionando correctamente.'],
+      ['280 - 350 ms', 'Tortuga', 'Por debajo de la media. Descansa o entrena más.'],
+      ['&gt; 350 ms', 'Dormido', 'Posible fatiga, sueño o hardware lento (input lag).'],
+    ],
+  },
+  { type: 'title' as const, text: '¿Por qué eres lento? Culpando al Hardware', level: 2 as const },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Monitor (Hz)',
+        description: 'Un monitor de 60Hz tarda ~16ms en pintar un cuadro. Uno de 144Hz tarda solo 7ms. Esa diferencia de 10ms cuenta en tu puntuación final.',
+        icon: 'mdi:monitor',
+        points: ['60Hz = ~16ms por frame', '144Hz = ~7ms por frame', 'Diferencia visible en test'],
+      },
+      {
+        title: 'Ratón Inalámbrico',
+        description: 'Los ratones bluetooth de oficina baratos tienen latencias altas. Para este test, usa cable o tecnología wireless 2.4GHz de baja latencia.',
+        icon: 'mdi:mouse-variant',
+        points: ['Bluetooth barato: +15-50ms', '2.4GHz gamer: <1ms extra', 'Cable USB: referencia'],
+      },
+      {
+        title: 'Navegador',
+        description: 'Las extensiones que bloquean anuncios o scripts pesados pueden causar "stuttering". Prueba en modo incógnito para tu récord real.',
+        icon: 'mdi:web',
+        points: ['Cierra extensiones pesadas', 'Modo incógnito = más limpio', 'Chrome/Firefox recomendado'],
+      },
+    ],
+  },
+];
+
+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<ReactionTesterUI> = { slug, title, description, ui, seo, faqTitle: 'Preguntas frecuentes', faq: faqData, bibliography: [], howTo, schemas };

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

@@ -0,0 +1,144 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { ReactionTesterUI } from '../ui';
+
+const slug = 'test-reflexes';
+const title = 'Test de Vitesse de Réaction (Réflexes): Benchmark en Ligne';
+const description = 'Mesurez vos réflexes en millisecondes avec notre test de réaction professionnel. Compétez pour des rangs de \'Tortue\' à \'Cyberathlète\' et analysez vos performances.';
+
+const ui: ReactionTesterUI = {
+  title: 'Test de Réflexes',
+  subtitle: 'Mesurez votre vitesse de réaction en millisecondes. Moyenne de 5 tentatives.',
+  startBtn: 'Cliquez pour commencer',
+  goTitle: 'ALLEZ!',
+  goSubtitle: 'CLIQUEZ MAINTENANT!',
+  earlyTitle: 'Trop tôt !',
+  earlySubtitle: 'Attendez le vert.',
+  earlyRetry: 'Cliquez pour réessayer',
+  promptNext: 'Clic pour tentative',
+  promptFinal: 'Voir les résultats finaux',
+  avgLabel: 'Moyenne finale',
+  copyBtn: 'Copier',
+  tweetBtn: 'Tweeter',
+  retryBtn: 'Réessayer',
+  inputMouse: 'Souris',
+  inputTouch: 'Tactile',
+  inputSpace: 'Espace',
+  historyTitle: 'Historique local',
+  historyBest: 'Top 5 Meilleurs',
+  historyWorst: 'Top 5 Pires',
+  historyEmpty: 'Jouez pour enregistrer votre premier score',
+  copySuccess: 'Copié !',
+  shareText: 'J\'ai obtenu {ms}ms au Test de Réflexes !\nRang : {rank}\n\nPeux-tu me battre ?\n{url}',
+  rankCiberatleta: 'Cyberathlète',
+  rankTigre: 'Tigre',
+  rankHumano: 'Humain',
+  rankTortuga: 'Tortue',
+  rankDormido: 'Endormi',
+  f150: 'ES-TU UN ROBOT ?!',
+  f180: 'INCROYABLE !',
+  f210: 'Très rapide !',
+  f250: 'Bonne réaction',
+  f300: 'Pas mal...',
+  f400: 'Un peu lent...',
+  f600: 'Tu t\'es endormi',
+  fSlow: 'Réveille-toi...',
+  wp0t: 'ATTENDS...', wp0s: 'Retiens ta respiration...',
+  wp1t: 'IMMOBILE...', wp1s: 'Ne cligne pas des yeux',
+  wp2t: 'PRÊT...', wp2s: 'Doigts prêts...',
+  wp3t: 'HOLD...', wp3s: 'Patience, sauterelle',
+  wp4t: 'FOCUS...', wp4s: 'Ça arrive...',
+};
+
+const faqData = [
+  { question: 'Quel est le temps de réaction moyen d\'un humain ?', answer: 'Le temps de réaction moyen d\'un humain à un stimulus visuel est d\'environ 250 à 270 millisecondes. Les athlètes de haut niveau et les pro-gamers sont généralement en dessous de 200ms.' },
+  { question: 'Comment puis-je améliorer mes réflexes ?', answer: 'La clé est la pratique constante et le repos. Jouer à des jeux vidéo d\'action (FPS), pratiquer des sports rapides comme le ping-pong et rester bien hydraté aide à maintenir le système nerveux alerte.' },
+  { question: 'L\'écran affecte-t-il mon résultat ?', answer: 'Oui. Il y a quelque chose appelé \'input lag\'. Les écrans à faible taux de rafraîchissement (60Hz) ou les vieilles souris sans fil peuvent ajouter 15 à 50ms à votre temps de réaction réel.' },
+  { question: 'À quel âge commence-t-on à perdre des réflexes ?', answer: 'Physiologiquement, les réflexes humains atteignent leur pic entre 20 et 24 ans. Ensuite, il y a un déclin très lent (environ 2-6ms par décennie) si on ne s\'entraîne pas.' },
+];
+
+const howTo = [
+  { name: 'Attendre le rouge', text: 'Cliquez sur la zone de départ et attendez patiemment que l\'écran change de couleur.' },
+  { name: 'Réagir au vert', text: 'Dès que vous voyez le vert, cliquez ou touchez l\'écran le plus vite possible.' },
+  { name: 'Voir le résultat', text: 'Le système calculera la différence exacte en millisecondes entre le changement de couleur et votre pression.' },
+  { name: 'Analyser votre rang', text: 'Répétez le test 5 fois pour obtenir une moyenne fiable et découvrir si vous êtes une \'Tortue\' ou un \'Cyberathlète\'.' },
+];
+
+const seo = [
+  { type: 'title' as const, text: 'Comment fonctionne ce Test de Réflexes ?', level: 2 as const },
+  {
+    type: 'paragraph' as const,
+    html: 'Cet outil mesure votre <strong>temps de réaction visuelle</strong> avec une précision chirurgicale. Nous calculons l\'intervalle exact depuis que l\'écran s\'illumine jusqu\'à ce que le signal voyage de vos yeux au cerveau, puis à vos doigts. Le test exige <strong>5 tentatives consécutives</strong> pour calculer votre vraie moyenne, éliminant le facteur chance.',
+  },
+  {
+    type: 'list' as const,
+    items: [
+      '<strong>Moyenne de 5 tentatives :</strong> Nous éliminons le facteur "chance" en exigeant la consistance. Un seul clic chanceux ne fera pas de vous un Cyberathlète.',
+      '<strong>Système anti-triche :</strong> Temps d\'attente aléatoires (1,5s - 4,5s) et détection des clics anticipés pour éviter les prédictions.',
+      '<strong>Science réelle :</strong> Traitement cérébral ~180-200ms + réponse motrice +20-40ms = votre temps de réaction total.',
+    ],
+  },
+  { type: 'title' as const, text: 'Tableau de Classement Mondial', level: 2 as const },
+  {
+    type: 'table' as const,
+    headers: ['Temps', 'Rang', 'Description'],
+    rows: [
+      ['&lt; 180 ms', 'Cyberathlète', 'Niveau surhumain typique des pros d\'eSports ou pilotes de chasse.'],
+      ['180 - 230 ms', 'Tigre', 'Réflexes aiguisés. Vous êtes probablement très bon aux shooters.'],
+      ['230 - 280 ms', 'Humain', 'La moyenne saine. Vous êtes éveillé et fonctionnez correctement.'],
+      ['280 - 350 ms', 'Tortue', 'En dessous de la moyenne. Reposez-vous ou entraînez-vous plus.'],
+      ['&gt; 350 ms', 'Endormi', 'Fatigue possible, sommeil ou matériel lent (input lag).'],
+    ],
+  },
+  { type: 'title' as const, text: 'Pourquoi êtes-vous lent ? La faute au matériel', level: 2 as const },
+  {
+    type: 'comparative' as const,
+    columns: 3 as const,
+    items: [
+      {
+        title: 'Moniteur (Hz)',
+        description: 'Un moniteur 60Hz met ~16ms à afficher une image. Un 144Hz seulement 7ms. Cette différence de 10ms compte dans votre score final.',
+        icon: 'mdi:monitor',
+        points: ['60Hz = ~16ms par image', '144Hz = ~7ms par image', 'Différence visible au test'],
+      },
+      {
+        title: 'Souris sans fil',
+        description: 'Les souris Bluetooth bon marché ont des latences élevées. Pour ce test, utilisez un câble ou la technologie sans fil 2,4GHz à faible latence.',
+        icon: 'mdi:mouse-variant',
+        points: ['Bluetooth bas de gamme: +15-50ms', '2,4GHz gaming: <1ms extra', 'Câble USB: référence'],
+      },
+      {
+        title: 'Navigateur',
+        description: 'Les extensions qui bloquent les publicités ou les scripts lourds peuvent causer du "stuttering". Essayez en mode incognito pour votre vrai record.',
+        icon: 'mdi:web',
+        points: ['Fermez les extensions lourdes', 'Incognito = plus propre', 'Chrome/Firefox recommandé'],
+      },
+    ],
+  },
+];
+
+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<ReactionTesterUI> = { slug, title, description, ui, seo, faqTitle: 'Questions fréquentes', faq: faqData, bibliography: [], howTo, schemas };

package/src/tool/reactionTester/index.ts

@@ -0,0 +1,34 @@
+import type { SportsToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import ReactionTesterComponent from './component.astro';
+import ReactionTesterSEO from './seo.astro';
+import ReactionTesterBibliography from './bibliography.astro';
+import type { ReactionTesterUI } from './ui';
+
+export type { ReactionTesterUI };
+export type ReactionTesterLocaleContent = ToolLocaleContent<ReactionTesterUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const reactionTester: SportsToolEntry<ReactionTesterUI> = {
+  id: 'reaction-tester',
+  icons: {
+    bg: 'mdi:lightning-bolt',
+    fg: 'mdi:timer-outline',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { ReactionTesterComponent, ReactionTesterSEO, ReactionTesterBibliography };
+
+export const REACTION_TESTER_TOOL: ToolDefinition = {
+  entry: reactionTester,
+  Component: ReactionTesterComponent,
+  SEOComponent: ReactionTesterSEO,
+  BibliographyComponent: ReactionTesterBibliography,
+};

package/src/tool/reactionTester/seo.astro

@@ -0,0 +1,12 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { reactionTester } from './index';
+import type { KnownLocale, ToolLocaleContent } from '../../types';
+import type { ReactionTesterUI } from './ui';
+
+interface Props { locale: KnownLocale }
+const { locale } = Astro.props;
+const content = await reactionTester.i18n[locale]?.() as ToolLocaleContent<ReactionTesterUI> | undefined;
+---
+
+{content && <SEORenderer content={{ locale: locale as string, sections: content.seo }} />}

package/src/tool/reactionTester/ui.ts

@@ -0,0 +1,43 @@
+export interface ReactionTesterUI {
+  title: string;
+  subtitle: string;
+  startBtn: string;
+  goTitle: string;
+  goSubtitle: string;
+  earlyTitle: string;
+  earlySubtitle: string;
+  earlyRetry: string;
+  promptNext: string;
+  promptFinal: string;
+  avgLabel: string;
+  copyBtn: string;
+  tweetBtn: string;
+  retryBtn: string;
+  inputMouse: string;
+  inputTouch: string;
+  inputSpace: string;
+  historyTitle: string;
+  historyBest: string;
+  historyWorst: string;
+  historyEmpty: string;
+  copySuccess: string;
+  shareText: string;
+  rankCiberatleta: string;
+  rankTigre: string;
+  rankHumano: string;
+  rankTortuga: string;
+  rankDormido: string;
+  f150: string;
+  f180: string;
+  f210: string;
+  f250: string;
+  f300: string;
+  f400: string;
+  f600: string;
+  fSlow: string;
+  wp0t: string; wp0s: string;
+  wp1t: string; wp1s: string;
+  wp2t: string; wp2s: string;
+  wp3t: string; wp3s: string;
+  wp4t: string; wp4s: string;
+}

package/src/tool/scoreKeeper/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography } from '@jjlmoya/utils-shared';
+import { scoreKeeper } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await scoreKeeper.i18n[locale]?.();
+---
+
+{content && <Bibliography links={content.bibliography} />}