@jjlmoya/utils-hardware 1.1.0

package/src/tool/mousePollingTest/component.astro

@@ -0,0 +1,237 @@
+---
+import type { KnownLocale } from '../../types';
+import type { TestRatonUI } from './ui';
+import { Icon } from 'astro-icon/components';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as TestRatonUI;
+---
+
+<div id="tr-root" class="tr-wrapper">
+
+  <style is:global>
+    .tr-wrapper {
+      --tr-accent: #10b981;
+      --tr-accent-glow: rgba(16, 185, 129, 0.4);
+      --tr-surface: #fff;
+      --tr-surface-alt: #f1f5f9;
+      --tr-surface-dark: #020617;
+      --tr-border: #e2e8f0;
+      --tr-text: #0f172a;
+      --tr-text-muted: #64748b;
+    }
+
+    .theme-dark .tr-wrapper {
+      --tr-surface: #0f172a;
+      --tr-surface-alt: #1e293b;
+      --tr-surface-dark: #020617;
+      --tr-border: #334155;
+      --tr-text: #f1f5f9;
+      --tr-text-muted: #94a3b8;
+    }
+
+    body.is-widget .tr-wrapper {
+      padding: 0;
+    }
+  </style>
+
+  <div class="tr-card">
+    <div class="tr-header">
+      <div class="tr-header-info">
+        <div class="tr-badge">
+          <Icon name="mdi:mouse" class="tr-badge-icon" />
+          {t.badge}
+        </div>
+        <h2 class="tr-title">{t.title}</h2>
+        <p class="tr-description">{t.description}</p>
+      </div>
+
+      <div class="tr-stats">
+        <div class="tr-stat">
+          <div class="tr-stat-label">{t.labelAvg}</div>
+          <div class="tr-stat-value">
+            <span id="tr-avg">0</span>
+            <span class="tr-stat-unit">Hz</span>
+          </div>
+        </div>
+        <div class="tr-stat">
+          <div class="tr-stat-label">{t.labelPeak}</div>
+          <div class="tr-stat-value">
+            <span id="tr-max">0</span>
+            <span class="tr-stat-unit">Hz</span>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div id="tr-area" class="tr-area">
+      <div id="tr-placeholder" class="tr-placeholder">{t.placeholder}</div>
+      <canvas id="tr-canvas" class="tr-canvas"></canvas>
+      <div id="tr-follower" class="tr-follower">0 Hz</div>
+    </div>
+  </div>
+
+  <style>
+    .tr-wrapper {
+      width: 100%;
+      max-width: 56rem;
+      margin: 0 auto;
+      color: var(--tr-text);
+    }
+
+    .tr-card {
+      background: var(--tr-surface);
+      border: 1px solid var(--tr-border);
+      border-radius: 1.5rem;
+      padding: 2rem;
+      box-shadow: 0 20px 40px -10px rgba(0, 0, 0, 0.1);
+      display: flex;
+      flex-direction: column;
+      gap: 1.5rem;
+    }
+
+    .tr-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      gap: 1rem;
+      flex-wrap: wrap;
+    }
+
+    .tr-header-info {
+      display: flex;
+      flex-direction: column;
+      gap: 0.25rem;
+    }
+
+    .tr-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.25rem 0.75rem;
+      border-radius: 9999px;
+      background: rgba(16, 185, 129, 0.1);
+      color: var(--tr-accent);
+      font-size: 0.75rem;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+
+    .tr-badge-icon {
+      width: 1rem;
+      height: 1rem;
+    }
+
+    .tr-title {
+      margin: 0;
+      font-size: 1.875rem;
+      font-weight: 900;
+      letter-spacing: -0.02em;
+    }
+
+    .tr-description {
+      margin: 0;
+      color: var(--tr-text-muted);
+    }
+
+    .tr-stats {
+      display: flex;
+      gap: 1rem;
+    }
+
+    .tr-stat {
+      background: var(--tr-surface-alt);
+      border-radius: 1rem;
+      padding: 1rem;
+      min-width: 7.5rem;
+      text-align: center;
+    }
+
+    .tr-stat-label {
+      font-size: 0.75rem;
+      font-weight: 700;
+      color: var(--tr-text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+
+    .tr-stat-value {
+      display: flex;
+      align-items: baseline;
+      justify-content: center;
+      gap: 0.25rem;
+      font-size: 2.25rem;
+      font-weight: 900;
+      color: var(--tr-accent);
+    }
+
+    .tr-stat-unit {
+      font-size: 1rem;
+      color: var(--tr-text-muted);
+    }
+
+    .tr-area {
+      position: relative;
+      width: 100%;
+      height: 400px;
+      background: var(--tr-surface-alt);
+      border-radius: 1rem;
+      border: 2px dashed var(--tr-border);
+      overflow: hidden;
+      cursor: crosshair;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .tr-placeholder {
+      color: var(--tr-border);
+      font-weight: 700;
+      font-size: 1.25rem;
+      pointer-events: none;
+      transition: opacity 200ms;
+    }
+
+    .tr-canvas {
+      position: absolute;
+      inset: 0;
+      width: 100%;
+      height: 100%;
+      opacity: 0.6;
+    }
+
+    .tr-follower {
+      position: absolute;
+      pointer-events: none;
+      background: var(--tr-accent);
+      color: #fff;
+      font-size: 0.75rem;
+      font-weight: 700;
+      padding: 0.25rem 0.5rem;
+      border-radius: 9999px;
+      box-shadow: 0 4px 10px var(--tr-accent-glow);
+      opacity: 0;
+      transition: opacity 75ms;
+      transform: translate(0, 0);
+    }
+  </style>
+
+  <script>
+    import { RatonManager } from './logic/RatonManager';
+
+    new RatonManager({
+      avg: document.getElementById('tr-avg'),
+      max: document.getElementById('tr-max'),
+      follower: document.getElementById('tr-follower'),
+      placeholder: document.getElementById('tr-placeholder'),
+      canvas: document.getElementById('tr-canvas') as HTMLCanvasElement | null,
+      area: document.getElementById('tr-area')
+    }, new URL('./worker/mouseWorker.ts', import.meta.url));
+  </script>
+</div>

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

@@ -0,0 +1,135 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TestRatonUI } from '../ui';
+
+const slug = 'mouse-polling-rate-test';
+const title = 'Online Mouse Polling Rate Test';
+const description =
+  'Check the real Hz of your mouse. Verify if your gaming mouse works at 1000Hz or more with our professional tool.';
+
+const faqData = [
+  {
+    question: 'What is the Polling Rate of a mouse?',
+    answer:
+      'It is the frequency at which the mouse reports its position to the computer, measured in Hz. A polling rate of 1000Hz means the mouse sends data every 1 millisecond, providing much smoother movement.',
+  },
+  {
+    question: 'Why does my test not reach 1000Hz constantly?',
+    answer:
+      'The browser can only measure polling rate when the mouse is moving. If you move it slowly or your CPU is very busy, the measurement may fluctuate. Move the mouse in fast circles to get the real maximum peak.',
+  },
+  {
+    question: 'Is it better to have the highest polling rate possible?',
+    answer:
+      'Generally yes for gaming (1000Hz or more), as it reduces lag. However, extremely high rates (4000Hz or 8000Hz) consume a lot of CPU resources and not all games are optimized for them.',
+  },
+  {
+    question: 'How does the monitor refresh rate affect the mouse?',
+    answer:
+      'If you have a 144Hz or 240Hz monitor, a low polling rate (125Hz) will make the pointer look choppy. For high-frequency monitors, it is essential to use at least 500Hz or 1000Hz.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Prepare the test area',
+    text: 'Place the cursor inside the capture zone of the tool.',
+  },
+  {
+    name: 'Move the mouse quickly',
+    text: 'Make fast, wide circular movements. The tool will calculate the intervals between each mousemove event sent by the hardware.',
+  },
+  {
+    name: 'Observe the stability graph',
+    text: 'Check if the Hz line is constant or has sudden drops, which could indicate interference in wireless mice or CPU issues.',
+  },
+  {
+    name: 'Analyze the response time',
+    text: 'Check the average Delay in milliseconds. A good gaming mouse should stay close to 1ms average latency.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<TestRatonUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'References',
+  bibliography: [
+    {
+      name: 'Gamepad Polling Rate — Logitech',
+      url: 'https://www.logitechg.com/en-us/innovation/delta-zero.html',
+    },
+    {
+      name: 'USB HID Polling Rate — USB Implementers Forum',
+      url: 'https://www.usb.org/hid',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Definitive Guide to Polling Rate', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'When you physically move your mouse on the mousepad, that analog movement must be translated into digital signals your computer understands. The <strong>Polling Rate</strong> is the frequency at which the mouse "reports" its position to the PC. It is measured in Hertz (Hz).',
+    },
+    { type: 'title', text: 'Polling Rate Levels and Their Uses', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>125 Hz</strong> — The mouse reports every 8 milliseconds. Fine for office use but feels choppy on 144Hz monitors. <strong>1000 Hz</strong> — The gaming gold standard: reports every 1 ms. Smooth movement with no perceptible delay. <strong>8000 Hz</strong> — Cutting-edge technology (Razer, Logitech). Reports every 0.125 ms but requires a powerful CPU.',
+    },
+    { type: 'title', text: 'Why Do My Hz Fluctuate?', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Completely normal. Most modern mice have a dynamic polling rate to save power. If you move the mouse slowly, it sends fewer reports because there is less new data. Only fast, continuous movements push the sensor to its real maximum peak.',
+    },
+    { type: 'title', text: 'Polling Rate vs DPI: The Big Confusion', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>DPI (Dots Per Inch)</strong> is sensitivity: how many pixels the cursor moves per inch of physical movement. <strong>Hz (Polling Rate)</strong> is update frequency: how smoothly and timely that movement is reported. Both parameters are independent and complementary.',
+    },
+  ],
+  ui: {
+    badge: 'Mouse Test',
+    title: 'Polling Rate Checker',
+    description: 'Move the mouse in fast circles to measure the Hz.',
+    labelAvg: 'Average',
+    labelPeak: 'Peak',
+    placeholder: 'Move the mouse here',
+  },
+};

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

@@ -0,0 +1,135 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TestRatonUI } from '../ui';
+
+const slug = 'test-raton';
+const title = 'Test de Polling Rate del Ratón Online';
+const description =
+  'Comprueba los Hz reales de tu ratón. Verifica si tu mouse gaming funciona a 1000Hz o más con nuestra herramienta profesional.';
+
+const faqData = [
+  {
+    question: '¿Qué es el Polling Rate de un ratón?',
+    answer:
+      'Es la frecuencia con la que el ratón informa de su posición al ordenador, medida en Hz. Un polling rate de 1000Hz significa que el ratón envía datos cada 1 milisegundo, proporcionando un movimiento mucho más fluido.',
+  },
+  {
+    question: '¿Por qué mi test no llega a 1000Hz constantes?',
+    answer:
+      'El navegador solo puede medir el polling rate cuando el ratón está en movimiento. Si lo mueves despacio o tu CPU está muy ocupada, la medición puede fluctuar. Mueve el ratón en círculos rápidos para obtener el pico máximo real.',
+  },
+  {
+    question: '¿Es mejor tener el polling rate más alto posible?',
+    answer:
+      'Generalmente sí para gaming (1000Hz o más), ya que reduce el lag. Sin embargo, tasas extremadamente altas (4000Hz o 8000Hz) consumen muchos recursos de CPU y no todos los juegos están optimizados para ello.',
+  },
+  {
+    question: '¿Cómo afecta la tasa de refresco del monitor al ratón?',
+    answer:
+      'Si tienes un monitor de 144Hz o 240Hz, un polling rate bajo (125Hz) hará que el puntero se vea a saltos. Para monitores de alta frecuencia, es imprescindible usar al menos 500Hz o 1000Hz.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Preparar el área de test',
+    text: 'Sitúa el cursor dentro de la zona de captura de la herramienta.',
+  },
+  {
+    name: 'Mover el ratón rápidamente',
+    text: 'Realiza movimientos circulares rápidos y amplios. La herramienta calculará los intervalos entre cada evento mousemove enviado por el hardware.',
+  },
+  {
+    name: 'Observar el gráfico de estabilidad',
+    text: 'Revisa si la línea de Hz es constante o si tiene caídas bruscas, lo que podría indicar interferencias en ratones inalámbricos o problemas de CPU.',
+  },
+  {
+    name: 'Analizar el tiempo de respuesta',
+    text: 'Verifica el Delay medio en milisegundos. Un buen ratón gaming debe mantenerse cerca de 1ms de latencia media.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'es',
+};
+
+export const content: ToolLocaleContent<TestRatonUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias',
+  bibliography: [
+    {
+      name: 'Gamepad Polling Rate — Logitech',
+      url: 'https://www.logitechg.com/en-us/innovation/delta-zero.html',
+    },
+    {
+      name: 'USB HID Polling Rate — USB Implementers Forum',
+      url: 'https://www.usb.org/hid',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Guía Definitiva sobre Polling Rate (tasa de sondeo)', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Cuando mueves tu ratón físico sobre la alfombrilla, ese movimiento analógico debe traducirse a señales digitales que tu ordenador entienda. El <strong>Polling Rate</strong> o Tasa de Sondeo es la frecuencia con la que el ratón "reporta" su posición al PC. Se mide en Hercios (Hz).',
+    },
+    { type: 'title', text: 'Niveles de Polling Rate y sus usos', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>125 Hz</strong> — El ratón informa cada 8 milisegundos. Perfecto para uso de oficina, pero se nota a tirones en monitores de 144Hz. <strong>1000 Hz</strong> — El estándar de oro del gaming: informa cada 1 ms. Movimiento fluido y sin retraso perceptible. <strong>8000 Hz</strong> — Tecnología punta (Razer, Logitech). Informa cada 0.125 ms, pero requiere una CPU potente.',
+    },
+    { type: 'title', text: '¿Por qué mis Hz fluctúan?', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Es completamente normal. La mayoría de ratones modernos tienen un polling rate dinámico para ahorrar energía. Si mueves el ratón despacio, enviará menos reportes porque hay menos datos nuevos. Solo cuando haces movimientos rápidos y continuos el sensor alcanza su pico máximo real.',
+    },
+    { type: 'title', text: 'Polling Rate vs DPI: La gran confusión', level: 3 },
+    {
+      type: 'paragraph',
+      html: '<strong>DPI (Dots Per Inch)</strong> es la sensibilidad: cuántos píxeles se mueve el cursor por cada pulgada de movimiento físico. <strong>Hz (Polling Rate)</strong> es la frecuencia de actualización: con qué suavidad y actualidad se reporta ese movimiento. Puedes tener 16.000 DPI con 125 Hz y el movimiento será lento e impreciso. Los dos parámetros son independientes y complementarios.',
+    },
+  ],
+  ui: {
+    badge: 'Mouse Test',
+    title: 'Polling Rate Checker',
+    description: 'Mueve el ratón en círculos rápidos para medir los Hz.',
+    labelAvg: 'Promedio',
+    labelPeak: 'Pico',
+    placeholder: 'Mueve el ratón aquí',
+  },
+};

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

@@ -0,0 +1,135 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TestRatonUI } from '../ui';
+
+const slug = 'test-taux-sondage-souris';
+const title = 'Test du Taux de Sondage de la Souris en Ligne';
+const description =
+  "Vérifiez les Hz réels de votre souris. Testez si votre souris gaming fonctionne à 1000Hz ou plus avec notre outil professionnel.";
+
+const faqData = [
+  {
+    question: "Qu'est-ce que le taux de sondage d'une souris ?",
+    answer:
+      "C'est la fréquence à laquelle la souris communique sa position à l'ordinateur, mesurée en Hz. Un taux de 1000Hz signifie que la souris envoie des données toutes les millisecondes, offrant un mouvement beaucoup plus fluide.",
+  },
+  {
+    question: "Pourquoi mon test n'atteint pas 1000Hz en continu ?",
+    answer:
+      "Le navigateur ne peut mesurer le taux de sondage que lorsque la souris est en mouvement. Si vous la déplacez lentement ou que votre CPU est très occupé, la mesure peut fluctuer. Faites des cercles rapides pour obtenir le vrai pic maximum.",
+  },
+  {
+    question: 'Est-il toujours préférable d\'avoir le taux de sondage le plus élevé possible ?',
+    answer:
+      "Généralement oui pour le gaming (1000Hz ou plus), car cela réduit la latence. Cependant, des taux extrêmement élevés (4000Hz ou 8000Hz) consomment beaucoup de ressources CPU et tous les jeux n'y sont pas optimisés.",
+  },
+  {
+    question: "Comment le taux de rafraîchissement du moniteur affecte-t-il la souris ?",
+    answer:
+      "Avec un moniteur 144Hz ou 240Hz, un faible taux de sondage (125Hz) donnera l'impression que le pointeur saccade. Pour les moniteurs haute fréquence, il est indispensable d'utiliser au moins 500Hz ou 1000Hz.",
+  },
+];
+
+const howToData = [
+  {
+    name: 'Préparer la zone de test',
+    text: "Placez le curseur dans la zone de capture de l'outil.",
+  },
+  {
+    name: 'Déplacer la souris rapidement',
+    text: "Effectuez des mouvements circulaires rapides et amples. L'outil calculera les intervalles entre chaque événement mousemove envoyé par le matériel.",
+  },
+  {
+    name: 'Observer le graphique de stabilité',
+    text: "Vérifiez si la ligne de Hz est constante ou présente des chutes brusques, ce qui pourrait indiquer des interférences sur les souris sans fil ou des problèmes de CPU.",
+  },
+  {
+    name: 'Analyser le temps de réponse',
+    text: "Vérifiez le Délai moyen en millisecondes. Une bonne souris gaming doit se maintenir proche de 1ms de latence moyenne.",
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'fr',
+};
+
+export const content: ToolLocaleContent<TestRatonUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Questions Fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références',
+  bibliography: [
+    {
+      name: 'Gamepad Polling Rate — Logitech',
+      url: 'https://www.logitechg.com/en-us/innovation/delta-zero.html',
+    },
+    {
+      name: 'USB HID Polling Rate — USB Implementers Forum',
+      url: 'https://www.usb.org/hid',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Guide Complet sur le Taux de Sondage', level: 2 },
+    {
+      type: 'paragraph',
+      html: "Lorsque vous déplacez physiquement votre souris sur le tapis, ce mouvement analogique doit être converti en signaux numériques compréhensibles par votre ordinateur. Le <strong>Taux de Sondage</strong> (Polling Rate) est la fréquence à laquelle la souris envoie sa position au PC, mesurée en Hertz (Hz).",
+    },
+    { type: 'title', text: 'Niveaux de Taux de Sondage et Leurs Usages', level: 3 },
+    {
+      type: 'paragraph',
+      html: "<strong>125 Hz</strong> — La souris communique toutes les 8 ms. Parfait pour un usage bureautique, mais saccadé sur un écran 144Hz. <strong>1000 Hz</strong> — L'étalon-or du gaming : communication toutes les 1 ms, mouvement fluide. <strong>8000 Hz</strong> — Technologie de pointe (Razer, Logitech), nécessite un processeur puissant.",
+    },
+    { type: 'title', text: 'Pourquoi mes Hz fluctuent-ils ?', level: 3 },
+    {
+      type: 'paragraph',
+      html: "Tout à fait normal. La plupart des souris modernes ont un taux de sondage dynamique pour économiser l'énergie. En déplaçant lentement la souris, elle envoie moins de rapports car il y a moins de nouvelles données. Seuls des mouvements rapides et continus poussent le capteur à son vrai pic maximum.",
+    },
+    { type: 'title', text: 'Taux de Sondage vs DPI : La Grande Confusion', level: 3 },
+    {
+      type: 'paragraph',
+      html: "<strong>DPI (Dots Per Inch)</strong> est la sensibilité : combien de pixels le curseur parcourt par pouce de déplacement physique. <strong>Hz (Taux de Sondage)</strong> est la fréquence de mise à jour : avec quelle fluidité et actualité ce mouvement est reporté. Les deux paramètres sont indépendants et complémentaires.",
+    },
+  ],
+  ui: {
+    badge: 'Test Souris',
+    title: 'Polling Rate Checker',
+    description: 'Déplacez la souris en cercles rapides pour mesurer les Hz.',
+    labelAvg: 'Moyenne',
+    labelPeak: 'Pic',
+    placeholder: 'Déplacez la souris ici',
+  },
+};

package/src/tool/mousePollingTest/index.ts

@@ -0,0 +1,34 @@
+import type { HardwareToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+
+import TestRatonComponent from './component.astro';
+import TestRatonSEO from './seo.astro';
+import TestRatonBibliography from './bibliography.astro';
+
+import type { TestRatonUI } from './ui';
+export type TestRatonLocaleContent = ToolLocaleContent<TestRatonUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const testRaton: HardwareToolEntry<TestRatonUI> = {
+  id: 'test-raton',
+  icons: {
+    bg: 'mdi:mouse-variant',
+    fg: 'mdi:mouse',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { TestRatonComponent, TestRatonSEO, TestRatonBibliography };
+
+export const TEST_RATON_TOOL: ToolDefinition = {
+  entry: testRaton,
+  Component: TestRatonComponent,
+  SEOComponent: TestRatonSEO,
+  BibliographyComponent: TestRatonBibliography,
+};