@jjlmoya/utils-hardware 1.21.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-hardware",
-    "version": "1.21.0",
+    "version": "1.22.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -5,6 +5,7 @@ import { testMando } from '../tool/gamepadTest/index';
 import { probadorVibracionMando } from '../tool/gamepadVibrationTester/index';
 import { testRaton } from '../tool/mousePollingTest/index';
 import { mouseDoubleClickTest } from '../tool/mouseDoubleClickTest/index';
+import { mouseScrollTest } from '../tool/mouseScrollTest/index';
 import { estimadorSaludBateria } from '../tool/batteryHealthEstimator/index';
 import { toneGenerator } from '../tool/toneGenerator/index';
 import { refreshRateDetector } from '../tool/refreshRateDetector/index';
@@ -14,7 +15,7 @@ import { upsRuntimeCalculator } from '../tool/upsRuntimeCalculator/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator],
+  tools: [pixelesPantalla, testTeclado, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -12,6 +12,8 @@ export { testRaton } from './tool/mousePollingTest/entry';
 export type { TestRatonLocaleContent } from './tool/mousePollingTest/entry';
 export { mouseDoubleClickTest } from './tool/mouseDoubleClickTest/entry';
 export type { MouseDoubleClickTestLocaleContent } from './tool/mouseDoubleClickTest/entry';
+export { mouseScrollTest } from './tool/mouseScrollTest/entry';
+export type { MouseScrollTestLocaleContent } from './tool/mouseScrollTest/entry';
 export { toneGenerator } from './tool/toneGenerator/entry';
 export type { ToneGeneratorLocaleContent } from './tool/toneGenerator/entry';
 export { refreshRateDetector } from './tool/refreshRateDetector/entry';
@@ -30,9 +32,10 @@ import { probadorVibracionMando } from './tool/gamepadVibrationTester/entry';
 import { testTeclado } from './tool/keyboardTest/entry';
 import { testRaton } from './tool/mousePollingTest/entry';
 import { mouseDoubleClickTest } from './tool/mouseDoubleClickTest/entry';
+import { mouseScrollTest } from './tool/mouseScrollTest/entry';
 import { toneGenerator } from './tool/toneGenerator/entry';
 import { refreshRateDetector } from './tool/refreshRateDetector/entry';
 import { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
 import { spectrumCanvas } from './tool/colorAccuracyTest/entry';
 import { upsRuntimeCalculator } from './tool/upsRuntimeCalculator/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator];
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator];

package/src/index.ts

@@ -23,6 +23,7 @@ export { TEST_MANDO_TOOL } from './tool/gamepadTest/index';
 export { PROBADOR_VIBRACION_MANDO_TOOL } from './tool/gamepadVibrationTester/index';
 export { TEST_RATON_TOOL } from './tool/mousePollingTest/index';
 export { MOUSE_DOUBLE_CLICK_TEST_TOOL } from './tool/mouseDoubleClickTest/index';
+export { MOUSE_SCROLL_TEST_TOOL } from './tool/mouseScrollTest/index';
 export { ESTIMADOR_SALUD_BATERIA_TOOL } from './tool/batteryHealthEstimator/index';
 export { TONE_GENERATOR_TOOL } from './tool/toneGenerator/index';
 export { REFRESH_RATE_DETECTOR_TOOL } from './tool/refreshRateDetector/index';

package/src/tests/locale_completeness.test.ts

@@ -21,8 +21,8 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('all 12 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(12);
+  it('all 13 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(13);
   });
 });
 

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { hardwareCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 12 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(12);
+    it('should have 13 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(13);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/mouseScrollTest/bibliography.astro

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

package/src/tool/mouseScrollTest/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Scroll wheel: mouse wheel hardware and common usage',
+    url: 'https://en.wikipedia.org/wiki/Scroll_wheel',
+  },
+  {
+    name: 'Rotary encoder: electromechanical sensing, wear, dust, and direction signals',
+    url: 'https://en.wikipedia.org/wiki/Rotary_encoder',
+  },
+  {
+    name: 'Incremental encoder: quadrature output and direction detection',
+    url: 'https://en.wikipedia.org/wiki/Incremental_encoder',
+  },
+];

package/src/tool/mouseScrollTest/component.astro

@@ -0,0 +1,150 @@
+---
+import type { KnownLocale } from '../../types';
+import type { MouseScrollTestUI } from './ui';
+import { Icon } from 'astro-icon/components';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as MouseScrollTestUI;
+---
+
+<div class="mst-root" id="mst-root" data-config={JSON.stringify({
+  statusIdle: t.statusIdle,
+  statusClean: t.statusClean,
+  statusWarning: t.statusWarning,
+  statusMixed: t.statusMixed,
+  upward: t.upward,
+  downward: t.downward,
+  leftward: t.leftward,
+  rightward: t.rightward,
+  noDirection: t.noDirection,
+  sensitivityUnit: t.sensitivityUnit,
+  emptyLog: t.emptyLog,
+  cleanEvent: t.cleanEvent,
+  reversalEvent: t.reversalEvent,
+  jitterEvent: t.jitterEvent,
+  verticalAxis: t.verticalAxis,
+  horizontalAxis: t.horizontalAxis,
+  noDataValue: t.noDataValue,
+})}>
+  <section class="mst-card">
+    <div id="mst-capture" class="mst-capture" data-capture-state="locked" tabindex="0" role="application" aria-label={t.captureTitle}>
+      <div class="mst-scope" aria-hidden="true">
+        <span class="mst-orbit mst-orbit-one"></span>
+        <span class="mst-orbit mst-orbit-two"></span>
+        <span class="mst-wheel">
+          <span class="mst-wheel-line"></span>
+          <span class="mst-wheel-line"></span>
+          <span class="mst-wheel-line"></span>
+        </span>
+      </div>
+      <div class="mst-capture-copy">
+        <span><Icon name="mdi:mouse" /> {t.badge}</span>
+        <small>{t.captureHint}</small>
+      </div>
+      <div class="mst-axis-grid" aria-hidden="true">
+        <span id="mst-vertical-needle" class="mst-needle mst-needle-vertical"></span>
+        <span id="mst-horizontal-needle" class="mst-needle mst-needle-horizontal"></span>
+      </div>
+      <div class="mst-focus-lock" aria-live="polite">
+        <span class="mst-lock-badge mst-lock-badge-locked">
+          <Icon name="mdi:lock" />
+          {t.focusLockTitle}
+        </span>
+        <p class="mst-lock-text mst-lock-text-locked">{t.focusLockText}</p>
+      </div>
+    </div>
+
+    <div class="mst-panel">
+      <div class="mst-score">
+        <span>{t.stabilityScore}</span>
+        <strong id="mst-score">100%</strong>
+        <small id="mst-status" data-state="idle">{t.statusIdle}</small>
+      </div>
+
+      <p class="mst-direction-note">{t.directionNote}</p>
+
+      <div class="mst-metrics">
+        <div>
+          <span>{t.totalTicks}</span>
+          <strong id="mst-total">0</strong>
+        </div>
+        <div>
+          <span>{t.reversals}</span>
+          <strong id="mst-reversals">0</strong>
+        </div>
+        <div>
+          <span>{t.longestRun}</span>
+          <strong id="mst-longest-run">0</strong>
+        </div>
+      </div>
+
+      <div class="mst-telemetry">
+        <div class="mst-axis-card">
+          <span>{t.verticalAxis}</span>
+          <b id="mst-vertical-meter"></b>
+        </div>
+        <div class="mst-axis-card">
+          <span>{t.horizontalAxis}</span>
+          <b id="mst-horizontal-meter"></b>
+        </div>
+      </div>
+
+      <div class="mst-readouts">
+        <div>
+          <span>{t.dominantDirection}</span>
+          <strong id="mst-dominant">{t.noDirection}</strong>
+        </div>
+        <div>
+          <span>{t.lastDelta}</span>
+          <strong id="mst-last-delta">{t.noDataValue}</strong>
+        </div>
+      </div>
+
+      <label class="mst-sensitivity">
+        <span>{t.sensitivityLabel}</span>
+        <b><span id="mst-sensitivity-value">12</span> {t.sensitivityUnit}</b>
+        <input id="mst-sensitivity" type="range" min="2" max="40" step="1" value="12" />
+      </label>
+
+      <div class="mst-log-head">
+        <span>{t.logTitle}</span>
+        <button id="mst-reset" type="button">{t.reset}</button>
+      </div>
+      <ol id="mst-log" class="mst-log"></ol>
+    </div>
+  </section>
+</div>
+
+<script>
+  import { MouseScrollTester } from './logic';
+
+  const root = document.getElementById('mst-root');
+  const labels = JSON.parse(root?.dataset.config ?? '{}');
+
+  new MouseScrollTester(
+    {
+      capture: document.getElementById('mst-capture'),
+      score: document.getElementById('mst-score'),
+      status: document.getElementById('mst-status'),
+      total: document.getElementById('mst-total'),
+      reversals: document.getElementById('mst-reversals'),
+      longestRun: document.getElementById('mst-longest-run'),
+      lastDelta: document.getElementById('mst-last-delta'),
+      dominant: document.getElementById('mst-dominant'),
+      sensitivity: document.getElementById('mst-sensitivity') as HTMLInputElement | null,
+      sensitivityValue: document.getElementById('mst-sensitivity-value'),
+      reset: document.getElementById('mst-reset'),
+      log: document.getElementById('mst-log'),
+      verticalNeedle: document.getElementById('mst-vertical-needle'),
+      horizontalNeedle: document.getElementById('mst-horizontal-needle'),
+      verticalMeter: document.getElementById('mst-vertical-meter'),
+      horizontalMeter: document.getElementById('mst-horizontal-meter'),
+    },
+    labels,
+  );
+</script>

package/src/tool/mouseScrollTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+
+import type { MouseScrollTestUI } from './ui';
+export type MouseScrollTestLocaleContent = ToolLocaleContent<MouseScrollTestUI>;
+
+export const mouseScrollTest: HardwareToolEntry<MouseScrollTestUI> = {
+  id: 'mouse-scroll-test',
+  icons: {
+    bg: 'mdi:mouse',
+    fg: 'mdi:swap-vertical-bold',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/mouseScrollTest/i18n/de.ts

@@ -0,0 +1,248 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { MouseScrollTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'mausrad-test';
+const title = 'Mausrad Test';
+const description = 'Diagnostizieren Sie Mausrad-Aussetzer, Rücksprünge, inkonsistente Scrollrichtung und schwache Encoder-Signale mit einem lokalen browserbasierten Mausrad-Test.';
+
+const faqData = [
+  {
+    question: 'Was erkennt ein Mausrad-Test?',
+    answer: 'Ein Mausrad-Test zeichnet Radereignisse auf und sucht nach instabilen Richtungswechseln, schwachen winzigen Deltas und inkonsistentem Scrollen. Diese Symptome treten häufig auf, wenn der Radencoder verschmutzt, abgenutzt, falsch ausgerichtet oder elektronisch gestört ist.',
+  },
+  {
+    question: 'Was ist ein Rücksprung beim Scrollen?',
+    answer: 'Ein Rücksprung tritt auf, wenn Sie in eine Richtung scrollen, der Computer jedoch ein kurzes Ereignis in die entgegengesetzte Richtung empfängt. Wiederholt sich dies bei gleichmäßigem Scrollen, ist dies ein starkes Zeichen für Encoder-Prellen oder Verschmutzung.',
+  },
+  {
+    question: 'Funktioniert dieser Test mit Touchpads?',
+    answer: 'Ja, aber das Ergebnis ist am aussagekräftigsten für physische Mausräder. Touchpads und sanfte Scrollräder erzeugen viele kleine Deltas, daher hilft die Empfindlichkeitssteuerung, beabsichtigte feine Bewegungen von verdächtigem Jitter zu trennen.',
+  },
+  {
+    question: 'Lädt der Test meine Mausdaten hoch?',
+    answer: 'Nein. Die Berechnung läuft lokal in Ihrem Browser. Das Tool verwendet nur Radereignisse, während sich der Mauszeiger im Erfassungsbereich befindet.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Platzieren Sie den Zeiger über dem Erfassungsfeld',
+    text: 'Bewegen Sie den Cursor in den Scroll-Laborbereich, damit die Seite Radereignisse erfassen kann, ohne das umgebende Dokument zu verschieben.',
+  },
+  {
+    name: 'Scrollen Sie gleichmäßig in eine Richtung',
+    text: 'Testen Sie jeweils eine Richtung: Rollen Sie langsam über mehrere Klicks nach oben, setzen Sie zurück oder pausieren Sie, dann testen Sie separat nach unten. Schnelle absichtliche Richtungswechsel können falsche Rücksprungwerte erzeugen.',
+  },
+  {
+    name: 'Achten Sie auf Rücksprünge',
+    text: 'Wenn der Umkehrzähler steigt, während Ihr Finger sich noch in eine Richtung bewegt, wiederholen Sie dieselbe Bewegung, um das Muster zu bestätigen.',
+  },
+  {
+    name: 'Stimmen Sie die Empfindlichkeit ab',
+    text: 'Erhöhen Sie die Empfindlichkeit für sanfte Touchpads oder senken Sie sie für strenge mechanische Radtests. Die Stabilitätsbewertung wird sofort aktualisiert.',
+  },
+];
+
+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: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<MouseScrollTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    {
+      type: 'title',
+      text: 'Mausrad Test: Radaussetzer und Rücksprünge finden',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein defektes Mausrad fällt selten auf einmal aus. Es beginnt meist mit kleinen Symptomen: eine Rastung scrollt in die falsche Richtung, die Seite springt nach oben während Sie nach unten scrollen, oder das Rad fühlt sich normal an, aber der Browser empfängt inkonsistente Ereignisse. Dieser Mausrad-Test zeichnet das Radsignal auf, das den Browser erreicht, und hebt die diagnostisch relevanten Muster hervor.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Ziel ist nicht zu messen, wie weit sich eine Seite bewegt hat. Das nützliche Signal ist die <strong>Richtungskonsistenz</strong>. Wenn Sie ein mechanisches Rad gleichmäßig nach unten drehen, sollte der Ereignisstrom in dieser Richtung bleiben. Kurze Gegensignale in einem engen Zeitfenster sind verdächtig, da sie dem Verhalten verschmutzter oder abgenutzter Scroll-Encoder entsprechen.',
+    },
+    {
+      type: 'title',
+      text: 'Was das Tool misst',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Gesamte Radpulse, die im Testfeld erfasst wurden',
+        'Rücksprünge: schnelle Vorzeichenwechsel, während die vorherige Richtung noch aktuell ist',
+        'Längster sauberer Lauf: wie viele aufeinanderfolgende Ereignisse in einer konsistenten Richtung blieben',
+        'Letztes Delta: Rohrichtung und Größe des jüngsten Radereignisses',
+        'Vertikale versus horizontale Aktivität, nützlich für Kippräder und Touchpads',
+      ],
+    },
+    {
+      type: 'table',
+      headers: ['Signal', 'Gesundes Muster', 'Verdächtiges Muster'],
+      rows: [
+        ['Vertikales Rad', 'Lange Folgen von Auf- oder Ab-Ereignissen bei gleichmäßigem Scrollen', 'Wechselnde Auf/Ab-Ereignisse, während Ihr Finger eine Richtung beibehält'],
+        ['Horizontale Neigung', 'Links- oder Rechtsereignisse nur bei Verwendung von Neige- oder horizontalen Gesten', 'Unerwartete seitliche Bewegung bei normaler vertikaler Radnutzung'],
+        ['Kleine Deltas', 'Gelegentlich kleine Werte bei sanften Rädern oder Touchpads', 'Hoher Anteil winziger instabiler Werte bei einem mechanischen Rastrad'],
+        ['Stabilitätsbewertung', 'Bleibt über mehrere bewusste Durchläufe hoch', 'Fällt wiederholt, weil Umkehrungen im gleichen Richtungstest auftreten'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Häufige Ursachen für Mausrad-Aussetzer',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die meisten Mausräder verwenden einen Encoder, der Drehung in Pulse umwandelt. Staub, Oxidation, abgenutzte Kontakte, eine lockere Radachse, Firmware-Filterprobleme oder ein beschädigtes Kabel können diese Pulse inkonsistent machen. Wenn der Encoder kurzzeitig die falsche Phase meldet, kann das Betriebssystem ein Radereignis in entgegengesetzter Richtung empfangen, obwohl sich das Rad in der ursprünglichen Richtung weiterbewegt hat.',
+    },
+    {
+      type: 'table',
+      headers: ['Symptom', 'Wahrscheinliche Ursache', 'Nächster Check'],
+      rows: [
+        ['Seite springt beim Runterscrollen nach oben', 'Encoder-Prellen oder Schmutz im Radmechanismus', 'Führen Sie einen langsamen Abwärtsdurchlauf durch und beobachten Sie den Umkehrzähler'],
+        ['Nur eine Anwendung scrollt schlecht', 'Anwendungsglättung, Zoom-Modus oder benutzerdefinierte Mausverknüpfung', 'Testen Sie im Browser und vergleichen Sie mit einer anderen App'],
+        ['Rad funktioniert nach Ausblasen, fällt dann wieder aus', 'Vorübergehende Schmutzverschiebung oder abgenutzte Encoder-Kontakte', 'Nach einigen Minuten normaler Nutzung wiederholen'],
+        ['Unerwartete horizontale Bewegung erscheint', 'Kipprad-Rauschen, Touchpad-Geste oder Treiberzuordnung', 'Überprüfen Sie die horizontale Achsanzeige während vertikalen Scrollens'],
+        ['Kabellose Maus scrollt unregelmäßig', 'Schwache Batterie, Empfängerentfernung oder Störungen', 'Mit frischer Batterie und nahem Empfänger erneut testen'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Zuverlässig testen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Platzieren Sie den Zeiger vor dem Scrollen im Erfassungsfeld, damit die Seite normale Seitenbewegungen verhindern kann',
+        'Testen Sie jeweils eine Richtung: scrollen Sie langsam 10 bis 20 Rastungen nach oben ohne Richtungswechsel',
+        'Zurücksetzen oder pausieren, dann denselben Einrichtungs-Durchlauf nach unten wiederholen',
+        'Wechseln Sie nicht schnell zwischen auf und ab, da absichtliche schnelle Richtungswechsel wie Rücksprünge aussehen können',
+        'Wenn Umkehrungen auftreten, wiederholen Sie die fehlerhafte Richtung mehrmals, um die Reproduzierbarkeit zu bestätigen',
+        'Vergleichen Sie mit einer anderen Maus am selben Computer, wenn Sie Hardware von Software trennen müssen',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Die Bewertung interpretieren',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Stabilitätsbewertung ist eine schnelle Zusammenfassung. Eine hohe Punktzahl bedeutet, dass das Tool konsistente Richtung und wenige winzige unsichere Deltas sah. Eine niedrige Punktzahl beweist nicht automatisch, dass die Maus defekt ist, besonders bei Touchpads oder hochauflösenden sanften Rädern, aber wiederholte Rücksprünge während eines langsamen Einrichtungstests sind starke Hinweise auf ein echtes Radproblem.',
+    },
+    {
+      type: 'table',
+      headers: ['Ergebnis', 'Bedeutung', 'Empfohlene Maßnahme'],
+      rows: [
+        ['Keine Umkehrungen und lange saubere Läufe', 'Das Radsignal erscheint konsistent', 'Nur weiter testen, wenn Symptome im realen Einsatz auftreten'],
+        ['Eine isolierte Umkehrung', 'Könnte versehentlicher Richtungswechsel oder ein Störereignis sein', 'Dieselbe Richtung langsam wiederholen'],
+        ['Mehrere Umkehrungen im selben Durchlauf', 'Wahrscheinlich Encoder-Prellen, Schmutz oder Radverschleiß', 'Auf anderem Computer erneut testen und Ergebnis dokumentieren'],
+        ['Viele Jitter-Ereignisse, aber keine Umkehrungen', 'Empfindlichkeit möglicherweise zu niedrig für den Gerätetyp', 'Empfindlichkeit für Touchpad oder Smooth-Scroll-Geräte erhöhen'],
+        ['Horizontale Ereignisse bei vertikaler Radnutzung', 'Mögliches Kipprad-Rauschen oder Treiberzuordnungsrauschen', 'Benutzerdefinierte Maussoftware deaktivieren und erneut testen'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Mechanisches Rad versus Touchpad',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein mechanisches Rastrad erzeugt normalerweise klare Richtungsschritte. Ein Touchpad oder ein frei drehbares Rad kann viele kleine Deltas erzeugen, da das Betriebssystem sanftes Scrollen anwendet. Deshalb enthält dieses Tool eine Empfindlichkeitssteuerung: Erhöhen ignoriert winzige Bewegungen und lässt den Test sich auf Richtungsänderungen konzentrieren, die groß genug sind, um relevant zu sein.',
+    },
+    {
+      type: 'title',
+      text: 'Was Sie vor dem Austausch der Maus versuchen sollten',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Testen Sie in einem anderen Browser, um einen seitenspezifischen Rad-Handler auszuschließen',
+        'Deaktivieren Sie herstellereigene Maussoftware, Scroll-Beschleunigung oder Makro-Ebenen während der Diagnose',
+        'Verwenden Sie bei kabellosen Mäusen eine frische Batterie und bringen Sie den Empfänger näher',
+        'Reinigen Sie die Umgebung des Rads mit Druckluft, während die Maus ausgesteckt oder ausgeschaltet ist',
+        'Wenn die Maus unter Garantie steht, dokumentieren Sie das wiederholte Umkehrmuster als Nachweis',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Browserbasierte Tests können den Encoder nicht elektrisch prüfen, aber sie können exakt zeigen, was Ihre normale Software empfängt. Wenn der Browser während eines sorgfältigen Einrichtungs-Scrollens Radereignisse in falscher Richtung empfängt, können andere Anwendungen sie ebenfalls empfangen.',
+    },
+  ],
+  ui: {
+    badge: 'Radsignal-Labor',
+    captureTitle: 'Scrollen Sie im Signalfeld',
+    captureHint: 'Verwenden Sie gleichmäßige Einrichtungs-Raddurchläufe, um Rücksprünge aufzudecken',
+    focusLockTitle: 'Diese Scroll-Zone aktivieren',
+    focusLockText: 'Klicken Sie auf diese Zone und scrollen Sie hier. Die Seite bewegt sich nicht, während diese Zone aktiv ist.',
+    stabilityScore: 'Stabilitätsbewertung',
+    statusIdle: 'Scrollen Sie über das Feld, um die Radkonsistenz zu messen',
+    statusClean: 'Die Radrichtung ist in den erfassten Proben stabil',
+    statusWarning: 'Rücksprünge beim letzten Scrollen erkannt',
+    statusMixed: 'Viele winzige Deltas erkannt; passen Sie die Empfindlichkeit für dieses Gerät an',
+    directionNote: 'Testen Sie jeweils eine Richtung. Schnelles Wechseln zwischen auf und ab kann falsche Rücksprungwerte erzeugen.',
+    totalTicks: 'Pulse',
+    reversals: 'Umkehrungen',
+    longestRun: 'Bester Lauf',
+    lastDelta: 'Letztes Delta',
+    verticalAxis: 'Vertikal',
+    horizontalAxis: 'Horizontal',
+    dominantDirection: 'Letzte Richtung',
+    upward: 'Auf',
+    downward: 'Ab',
+    leftward: 'Links',
+    rightward: 'Rechts',
+    noDirection: 'Keine Bewegung',
+    noDataValue: '-',
+    sensitivityLabel: 'Jitter-Empfindlichkeit',
+    sensitivityUnit: 'Delta',
+    reset: 'Zurücksetzen',
+    logTitle: 'Radereignis-Protokoll',
+    emptyLog: 'Scrollen Sie mit langsamer, gleichmäßiger Radbewegung über das Feld.',
+    cleanEvent: 'sauber',
+    reversalEvent: 'Rücksprung',
+    jitterEvent: 'winziges Delta',
+  },
+};