@jjlmoya/utils-hardware 1.28.0 → 1.30.0

package/package.json

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

package/src/category/index.ts

@@ -8,6 +8,7 @@ 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 { subwooferCrossoverTest } from '../tool/subwooferCrossoverTest/index';
 import { refreshRateDetector } from '../tool/refreshRateDetector/index';
 import { monitorGhostingTest } from '../tool/monitorGhostingTest/index';
 import { spectrumCanvas } from '../tool/colorAccuracyTest/index';
@@ -18,10 +19,11 @@ import { keyboardChatterTest } from '../tool/keyboardChatterTest/index';
 import { webUsbSerialMonitor } from '../tool/webUsbSerialMonitor/index';
 import { usbPowerBudgetCalculator } from '../tool/usbPowerBudgetCalculator/index';
 import { mobileSensorTest } from '../tool/mobileSensorTest/index';
+import { mouseJitterAngleSnappingTest } from '../tool/mouseJitterAngleSnappingTest/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
+  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, mouseJitterAngleSnappingTest, estimadorSaludBateria, toneGenerator, subwooferCrossoverTest, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -16,6 +16,8 @@ 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 { subwooferCrossoverTest } from './tool/subwooferCrossoverTest/entry';
+export type { SubwooferCrossoverTestLocaleContent } from './tool/subwooferCrossoverTest/entry';
 export { refreshRateDetector } from './tool/refreshRateDetector/entry';
 export type { RefreshRateDetectorLocaleContent } from './tool/refreshRateDetector/entry';
 export { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
@@ -36,6 +38,8 @@ export { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry'
 export type { UsbPowerBudgetCalculatorLocaleContent } from './tool/usbPowerBudgetCalculator/entry';
 export { mobileSensorTest } from './tool/mobileSensorTest/entry';
 export type { MobileSensorTestLocaleContent } from './tool/mobileSensorTest/entry';
+export { mouseJitterAngleSnappingTest } from './tool/mouseJitterAngleSnappingTest/entry';
+export type { MouseJitterAngleSnappingTestLocaleContent } from './tool/mouseJitterAngleSnappingTest/entry';
 export { hardwareCategory } from './category';
 import { estimadorSaludBateria } from './tool/batteryHealthEstimator/entry';
 import { pixelesPantalla } from './tool/deadPixelTest/entry';
@@ -46,6 +50,7 @@ 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 { subwooferCrossoverTest } from './tool/subwooferCrossoverTest/entry';
 import { refreshRateDetector } from './tool/refreshRateDetector/entry';
 import { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
 import { spectrumCanvas } from './tool/colorAccuracyTest/entry';
@@ -56,4 +61,5 @@ import { keyboardChatterTest } from './tool/keyboardChatterTest/entry';
 import { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
 import { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry';
 import { mobileSensorTest } from './tool/mobileSensorTest/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];
+import { mouseJitterAngleSnappingTest } from './tool/mouseJitterAngleSnappingTest/entry';
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, mouseJitterAngleSnappingTest, toneGenerator, subwooferCrossoverTest, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];

package/src/index.ts

@@ -26,6 +26,7 @@ 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 { SUBWOOFER_CROSSOVER_TEST_TOOL } from './tool/subwooferCrossoverTest/index';
 export { REFRESH_RATE_DETECTOR_TOOL } from './tool/refreshRateDetector/index';
 export { MONITOR_GHOSTING_TEST_TOOL } from './tool/monitorGhostingTest/index';
 export { SPECTRUM_CANVAS_TOOL } from './tool/colorAccuracyTest/index';
@@ -36,3 +37,4 @@ export { KEYBOARD_CHATTER_TEST_TOOL } from './tool/keyboardChatterTest/index';
 export { WEB_USB_SERIAL_MONITOR_TOOL } from './tool/webUsbSerialMonitor/index';
 export { USB_POWER_BUDGET_CALCULATOR_TOOL } from './tool/usbPowerBudgetCalculator/index';
 export { MOBILE_SENSOR_TEST_TOOL } from './tool/mobileSensorTest/index';
+export { MOUSE_JITTER_ANGLE_SNAPPING_TEST_TOOL } from './tool/mouseJitterAngleSnappingTest/index';

package/src/tests/locale_completeness.test.ts

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

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { hardwareCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have all tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(19);
+      expect(ALL_TOOLS.length).toBe(21);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/mouseJitterAngleSnappingTest/bibliography.astro

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

package/src/tool/mouseJitterAngleSnappingTest/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Mouse sensor angle snapping and prediction explained by Blur Busters',
+    url: 'https://blurbusters.com/faq/mouse-guide/',
+  },
+  {
+    name: 'Mouse acceleration, raw input, and pointer precision notes from PCGamingWiki',
+    url: 'https://www.pcgamingwiki.com/wiki/Glossary:Mouse_acceleration',
+  },
+  {
+    name: 'Human Interface Device pointer behavior and mouse input terminology',
+    url: 'https://en.wikipedia.org/wiki/Computer_mouse',
+  },
+];

package/src/tool/mouseJitterAngleSnappingTest/component.astro

@@ -0,0 +1,110 @@
+---
+import type { KnownLocale } from '../../types';
+import type { MouseJitterAngleSnappingTestUI } from './ui';
+import { Icon } from 'astro-icon/components';
+import './mouse-jitter-angle-snapping-test.css';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as MouseJitterAngleSnappingTestUI;
+---
+
+<div class="mjas-root" id="mjas-root" data-config={JSON.stringify({
+  statusIdle: t.statusIdle,
+  statusHealthy: t.statusHealthy,
+  statusJitter: t.statusJitter,
+  statusSnapping: t.statusSnapping,
+  statusMixed: t.statusMixed,
+  emptyLog: t.emptyLog,
+  jitterEvent: t.jitterEvent,
+  snappingEvent: t.snappingEvent,
+  combinedEvent: t.combinedEvent,
+  cleanEvent: t.cleanEvent,
+  pxUnit: t.pxUnit,
+  percentUnit: t.percentUnit,
+})}>
+  <section class="mjas-shell">
+    <div id="mjas-stage" class="mjas-stage" role="application" aria-label={t.canvasLabel}>
+      <canvas id="mjas-canvas" class="mjas-canvas"></canvas>
+      <div class="mjas-canvas-copy">
+        <span><Icon name="mdi:mouse-move-down" /> {t.badge}</span>
+        <strong>{t.pointerPrompt}</strong>
+        <small>{t.canvasHint}</small>
+      </div>
+    </div>
+
+    <aside class="mjas-console">
+      <div class="mjas-status">
+        <span>{t.samples}</span>
+        <strong id="mjas-samples">0</strong>
+        <small id="mjas-status" data-state="idle">{t.statusIdle}</small>
+      </div>
+
+      <div class="mjas-score-grid">
+        <div>
+          <span>{t.jitterScore}</span>
+          <strong id="mjas-jitter-score">0{t.percentUnit}</strong>
+        </div>
+        <div>
+          <span>{t.snappingScore}</span>
+          <strong id="mjas-snapping-score">0{t.percentUnit}</strong>
+        </div>
+      </div>
+
+      <div class="mjas-readouts">
+        <div>
+          <span>{t.straightness}</span>
+          <strong id="mjas-straightness">0{t.percentUnit}</strong>
+        </div>
+        <div>
+          <span>{t.rawDeviation}</span>
+          <strong id="mjas-deviation">0{t.pxUnit}</strong>
+        </div>
+      </div>
+
+      <label class="mjas-sensitivity">
+        <span>{t.sensitivity}</span>
+        <b><em>{t.low}</em><strong id="mjas-sensitivity-value">50</strong><em>{t.high}</em></b>
+        <input id="mjas-sensitivity" type="range" min="20" max="90" value="50" step="1" />
+      </label>
+
+      <div class="mjas-actions">
+        <button id="mjas-reset" type="button"><Icon name="mdi:restore" /> {t.reset}</button>
+      </div>
+
+      <p class="mjas-shift">{t.holdShift}</p>
+
+      <div class="mjas-log-head">{t.traceLog}</div>
+      <ol id="mjas-log" class="mjas-log"></ol>
+    </aside>
+  </section>
+</div>
+
+<script>
+  import { MouseJitterAngleSnappingTester } from './logic';
+
+  const root = document.getElementById('mjas-root');
+  const labels = JSON.parse(root?.dataset.config ?? '{}');
+
+  new MouseJitterAngleSnappingTester(
+    {
+      stage: document.getElementById('mjas-stage'),
+      canvas: document.getElementById('mjas-canvas') as HTMLCanvasElement | null,
+      samples: document.getElementById('mjas-samples'),
+      jitterScore: document.getElementById('mjas-jitter-score'),
+      snappingScore: document.getElementById('mjas-snapping-score'),
+      straightness: document.getElementById('mjas-straightness'),
+      deviation: document.getElementById('mjas-deviation'),
+      status: document.getElementById('mjas-status'),
+      sensitivity: document.getElementById('mjas-sensitivity') as HTMLInputElement | null,
+      sensitivityValue: document.getElementById('mjas-sensitivity-value'),
+      reset: document.getElementById('mjas-reset'),
+      log: document.getElementById('mjas-log'),
+    },
+    labels,
+  );
+</script>

package/src/tool/mouseJitterAngleSnappingTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+
+import type { MouseJitterAngleSnappingTestUI } from './ui';
+export type MouseJitterAngleSnappingTestLocaleContent = ToolLocaleContent<MouseJitterAngleSnappingTestUI>;
+
+export const mouseJitterAngleSnappingTest: HardwareToolEntry<MouseJitterAngleSnappingTestUI> = {
+  id: 'mouse-jitter-angle-snapping-test',
+  icons: {
+    bg: 'mdi:mouse',
+    fg: 'mdi:vector-line',
+  },
+  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/mouseJitterAngleSnappingTest/i18n/de.ts

@@ -0,0 +1,289 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { MouseJitterAngleSnappingTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'maus-jitter-winkelkorrektur-test';
+const title = 'Maus Jitter und Winkelkorrektur Test';
+const description =
+  'Zeichne rohe Mausspuren online, um Sensor-Jitter, wackelige Verfolgung und Winkelkorrektur oder Vorhersage zu erkennen, die die Bewegung künstlich gerade macht.';
+
+const faqData = [
+  {
+    question: 'Was ist Maus-Jitter?',
+    answer:
+      'Maus-Jitter ist unerwünschtes Zittern oder verrauschtes Verhalten im Cursorpfad, selbst wenn sich die Hand gleichmäßig bewegt. Ursachen können ein verschmutztes Sensorfenster, eine schlechte Oberfläche, hohes Lift-Off-Verhalten, elektrisches Rauschen, drahtlose Instabilität oder ein Sensor sein, der bei der gewählten DPI-Stufe Probleme hat.',
+  },
+  {
+    question: 'Was ist Winkelkorrektur?',
+    answer:
+      'Winkelkorrektur, manchmal auch Vorhersage genannt, ist eine Korrekturfunktion, bei der die Maus-Firmware versucht, leicht unvollkommene menschliche Bewegungen in geradere horizontale, vertikale oder diagonale Linien umzuwandeln. Manche Büroanwender mögen das, aber viele Gamer und Künstler bevorzugen rohe Bewegung ohne Vorhersage.',
+  },
+  {
+    question: 'Kann dieser Test beweisen, dass mein Maussensor defekt ist?',
+    answer:
+      'Er kann den Sensor nicht elektrisch prüfen, aber er zeigt den Bewegungspfad, den dein Browser empfängt. Wenn wiederholte sanfte Bewegungen verrauschte Punkte, plötzliche Abweichungen oder unnatürlich gerade Segmente erzeugen, ist das Ergebnis ein nützlicher Hinweis zur Fehlerbehebung bei Maus, Oberfläche, DPI, Funkverbindung oder Firmware-Einstellungen.',
+  },
+  {
+    question: 'Wie sollte ich zeichnen, um das zuverlässigste Ergebnis zu erhalten?',
+    answer:
+      'Zeichne langsame diagonale Linien, mittelschnelle Kurven und lange horizontale Striche. Wiederhole dieselbe Bewegung mehrmals. Jitter ist in langsamen, kontrollierten Linien leichter zu erkennen, während Winkelkorrektur leichter auffällt, wenn diagonale Bewegungen verdächtig gerade oder treppenförmig werden.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Sensor und Mauspad reinigen',
+    text: 'Entferne vor dem Test Staub oder Haare vom Sensorfenster und verwende ein stabiles Mauspad oder eine Schreibtischoberfläche.',
+  },
+  {
+    name: 'Langsame diagonale Linien zeichnen',
+    text: 'Halte die primäre Maustaste gedrückt und zeichne mehrere diagonale Striche. Ein roher Sensor sollte natürliche Handvariation zeigen, keine perfekt auf einen Winkel gezwungene Linie.',
+  },
+  {
+    name: 'Sanfte Kurven zeichnen',
+    text: 'Mache Kreise, S-Kurven und Bögen. Jitter erscheint als raue, verrauschte Punkte, die von der beabsichtigten Kurve abweichen.',
+  },
+  {
+    name: 'DPI- und Oberflächeneinstellungen vergleichen',
+    text: 'Wiederhole dieselbe Bewegung bei verschiedenen DPI-Stufen, Polling-Raten, Lift-Off-Einstellungen und Oberflächen, um herauszufinden, wann das Problem auftritt.',
+  },
+];
+
+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<MouseJitterAngleSnappingTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    {
+      type: 'title',
+      text: 'Maus-Jitter-Test Online: Sensorrauschen und Winkelkorrektur prüfen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein guter Maussensor sollte deiner Hand folgen, ohne sichtbares Rauschen hinzuzufügen oder den Pfad heimlich zu korrigieren. Wenn der Sensor verschmutzt, die Oberfläche schwer zu verfolgen, der DPI-Wert zu hoch für die Hardware oder die Firmware wendet Vorhersage an, kann sich der Cursorpfad nicht mehr natürlich anfühlen. Dieser Maus-Jitter-Test lässt dich rohe Spuren zeichnen und die einzelnen Lesepunkte überprüfen, damit Sensorprobleme sichtbar statt vage werden.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die nützlichste Art zu testen ist einfach: Zeichne kontrollierte Linien und Kurven und betrachte dann die Form der Spur. Ein gesunder Rohsensor erzeugt einen Pfad, der deiner Bewegung mit kleinen menschlichen Unvollkommenheiten folgt. Ein verrauschter Sensor erzeugt raue Punkte, winzige Spitzen und ungleichmäßiges Wackeln. Eine Maus mit Winkelkorrektur oder Vorhersage kann diagonale oder horizontale Bewegungen unnatürlich gerade erscheinen lassen, als würde die Firmware deine Hand korrigieren.',
+    },
+    {
+      type: 'title',
+      text: 'Wie Maus-Jitter aussieht',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Maus-Jitter ist nicht dasselbe wie normales Händezittern. Jeder zeichnet leicht unvollkommene Linien. Jitter wird verdächtig, wenn die Punkte von der Bewegungsrichtung abweichen, obwohl sich deine Hand langsam und gleichmäßig bewegt. Er erscheint oft als unscharfer Rand um eine Linie, kleine seitliche Spitzen oder eine Spur, die kratzig statt glatt aussieht.',
+    },
+    {
+      type: 'table',
+      headers: ['Spurmuster', 'Wahrscheinliche Bedeutung', 'Als Nächstes versuchen'],
+      rows: [
+        ['Kleine zufällige Spitzen bei langsamen Linien', 'Sensorrauschen, Schmutz oder Oberflächenproblem', 'Sensorfenster reinigen und anderes Mauspad ausprobieren'],
+        ['Jitter nur bei hohem DPI', 'Sensor oder Firmware hat Probleme mit dieser Empfindlichkeit', 'Erneut bei 400, 800, 1600 und 3200 DPI testen'],
+        ['Raue Bewegung nur bei Funkbetrieb', 'Akku, Empfängerentfernung oder Störung', 'Empfänger näher platzieren und mit frischem Akku testen'],
+        ['Rauschen beim Anheben oder Kippen der Maus', 'Lift-Off-Distanz oder ungleichmäßiger Oberflächenkontakt', 'Maus flach halten und Lift-Off-Distanz wenn möglich verringern'],
+        ['Jitter auf einem Schreibtisch, aber nicht auf einem anderen', 'Oberflächentextur oder Reflektivitätsproblem', 'Mattes Mauspad für optische Sensoren verwenden'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Wie Winkelkorrektur aussieht',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Winkelkorrektur unterscheidet sich von Jitter. Statt Rauschen hinzuzufügen, entfernt sie natürliche Variation. Wenn du eine diagonale Linie von Hand zeichnest, sollte ein Rohsensor winzige menschliche Abweichungen bewahren. Mit aktivierter Winkelkorrektur kann die Linie in eine perfekt gerade horizontale, vertikale oder diagonale Richtung einrasten. Dies kann das Zeichnen auf dem Desktop erleichtern, ist aber meist unerwünscht für kompetitives Zielen, Pixel-Art, Bildbearbeitung und jede Aufgabe, bei der der Cursor genau der Hand entsprechen soll.',
+    },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Rohsensor Verhalten',
+          description: 'Die Spur folgt deiner Hand, einschließlich kleiner natürlicher Kurven und Korrekturen. Diagonale Linien sind nicht mathematisch perfekt, es sei denn, deine Bewegung war es.',
+        },
+        {
+          title: 'Winkelkorrektur Verhalten',
+          description: 'Die Spur sieht über lange Abschnitte verdächtig gerade aus, besonders in der Nähe üblicher Winkel wie horizontal, vertikal oder 45 Grad.',
+        },
+        {
+          title: 'Jitter Verhalten',
+          description: 'Die Spur wird verrauscht, unscharf oder spitz. Statt zu gerade zu sein, wirkt sie instabil und rau.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'So testest du deine Maus richtig',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Beginne mit einem sauberen Sensorfenster und einem bewährten Mauspad',
+        'Zeichne langsame diagonale Linien von Ecke zu Ecke und wiederhole dieselbe Bewegung mehrmals',
+        'Zeichne Kreise und S-Kurven, um Jitter aufzudecken, der in geraden Linien nicht sichtbar ist',
+        'Teste bei mehreren DPI-Stufen, da manche Sensoren bei sehr hoher Empfindlichkeit verrauschter werden',
+        'Deaktiviere Herstellersoftware-Funktionen wie Winkelkorrektur, Vorhersage, Oberflächenabstimmung oder Beschleunigung, wenn möglich',
+        'Vergleiche Kabel- und Funkmodus, wenn deine Maus beides unterstützt',
+        'Vergleiche mit einer anderen Maus auf derselben Oberfläche, um Mausdefekte von Oberflächenproblemen zu trennen',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Die Bewertungen verstehen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Tool zeigt einen Jitter-Wert, einen Winkelkorrektur-Wert, Geradheit, durchschnittliche Abweichung und die Anzahl der erfassten Proben. Diese Werte sollten am besten vergleichend verwendet werden. Zeichne dieselbe Linie mit derselben Handbewegung, nachdem du eine Variable geändert hast: DPI, Oberfläche, Platzierung des Funkempfängers oder Maus-Firmware-Einstellung. Wenn ein Wert nach dem Wechsel der Oberfläche oder der Reinigung des Sensors sinkt, hast du eine wahrscheinliche Ursache gefunden.',
+    },
+    {
+      type: 'table',
+      headers: ['Ergebnis', 'Was es nahelegt', 'Praktische Maßnahme'],
+      rows: [
+        ['Niedriger Jitter und niedrige Korrektur', 'Der Sensorpfad wirkt natürlich und stabil', 'Aktuelle Einstellungen beibehalten und als Referenz nutzen'],
+        ['Hoher Jitter, niedrige Korrektur', 'Die Maus verfolgt, aber der Pfad ist verrauscht', 'Sensor reinigen, Oberfläche wechseln, DPI senken und erneut testen'],
+        ['Niedriger Jitter, hohe Korrektur', 'Der Pfad könnte firmware-korrigiert sein', 'Nach Vorhersage- oder Winkelkorrektur-Einstellungen in der Maus-Software suchen'],
+        ['Hoher Jitter und hohe Korrektur', 'Die Spur ist instabil und möglicherweise überkorrigiert', 'Maus-Software-Profile zurücksetzen und ab Werkseinstellungen erneut testen'],
+        ['Werte ändern sich stark je nach Oberfläche', 'Dem Sensor gefällt eine Oberflächentextur oder Reflektivität nicht', 'Die Oberfläche mit der saubersten Spur verwenden'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'DPI, Polling-Rate und Maus-Jitter',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Hohe DPI bedeuten nicht automatisch bessere Verfolgung. Manche Mäuse funktionieren bei moderaten DPI sauber, zeigen aber bei sehr hohen DPI mehr sichtbares Rauschen, weil winzige Sensorfehler in größere Cursorbewegungen verstärkt werden. Die Polling-Rate kann ebenfalls das Gefühl der Spur verändern. Eine höhere Polling-Rate liefert häufigere Aktualisierungen, kann aber einen verschmutzten Sensor, eine schlechte Oberfläche oder Firmware-Vorhersage nicht beheben.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Für einen fairen Vergleich halte deine Handbewegung ähnlich und ändere jeweils nur eine Einstellung. Zeichne zum Beispiel dieselbe diagonale Linie bei 800 DPI, 1600 DPI und 3200 DPI. Wenn die Spur nur beim höchsten Wert unscharf wird, kann die beste Lösung sein, den DPI zu senken und die Empfindlichkeit im Spiel anzupassen, statt die Maus zu ersetzen.',
+    },
+    {
+      type: 'title',
+      text: 'Häufige Ursachen für Maussensor-Jitter',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Staub, Haare oder Fett in der Nähe des optischen Sensorfensters',
+        'Glänzende, reflektierende, transparente oder unebene Oberflächen',
+        'Sehr hohe DPI-Einstellungen, die kleine Sensorfehler verstärken',
+        'Schwacher Akku oder Funkstörungen',
+        'Empfänger weit von der Maus entfernt oder hinter einem Metall-PC-Gehäuse',
+        'Firmware-Filter, Oberflächenkalibrierung oder Herstellersoftware-Profile',
+        'Lift-Off-Distanz-Probleme, wenn die Maus gekippt oder schnell bewegt wird',
+        'Eine abgenutzte oder beschädigte Sensorlinse nach intensiver Nutzung',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum es Gamer und Designer interessiert',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'In Spielen kann Jitter Mikroanpassungen erschweren, weil das Fadenkreuz nicht genau dort zur Ruhe kommt, wo die Hand es beabsichtigt hat. Winkelkorrektur kann ebenso problematisch sein: Sie mag beim Zeichnen gerader Desktop-Linien helfen, kann aber auch kleine Zielkorrekturen verzerren und diagonales Tracking gefiltert wirken lassen. Für Designer, Illustratoren, CAD-Anwender und Bildbearbeiter kann Sensorkorrektur die Freihandbewegung weniger ehrlich und schwerer kontrollierbar machen.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine Maus braucht keine perfekte Spur, um gut zu sein. Menschliche Bewegung ist von Natur aus unvollkommen. Die Warnsignale sind wiederholbar: Dieselbe Oberfläche erzeugt immer verrauschte Punkte, dieselbe DPI erzeugt immer Spitzen, oder dieselbe Maus macht Diagonalen immer verdächtig gerade, während eine andere Maus das nicht tut.',
+    },
+    {
+      type: 'title',
+      text: 'Bevor du eine neue Maus kaufst',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Reinige das Sensorfenster vorsichtig bei ausgeschalteter Maus',
+        'Probiere ein anderes Mauspad, vorzugsweise mattes Stoff- oder Hybrid-Gaming-Pad',
+        'Senke den DPI und gleiche mit Software-Empfindlichkeit aus',
+        'Deaktiviere Winkelkorrektur, Vorhersage, Zeigergenauigkeit und Beschleunigungsoptionen',
+        'Bringe den Funkempfänger mit einem USB-Verlängerungskabel näher',
+        'Aktualisiere oder setze das Maus-Firmware-Profil zurück, falls die Herstellersoftware es unterstützt',
+        'Teste eine andere Maus am selben Computer und auf derselben Oberfläche zum Vergleich',
+      ],
+    },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Die nützliche Diagnoseregel',
+      html: '<p>Eine einzelne seltsame Spur reicht nicht aus. Ein wiederholbares Muster ist entscheidend. Wenn Jitter oder Winkelkorrektur unter denselben Einstellungen immer wieder auftritt und dann verschwindet, wenn du den Sensor reinigst, die Oberfläche wechselst, den DPI senkst oder die Vorhersage deaktivierst, hast du die wahrscheinlichste Ursache gefunden.</p>',
+    },
+  ],
+  ui: {
+    badge: 'Rohe Sensorspur',
+    canvasLabel: 'Zeichenbereich für Maus-Jitter- und Winkelkorrektur-Test',
+    canvasHint: 'Zeichne langsame Diagonalen, Kreise und Kurven. Einzelne Sensorpunkte bleiben sichtbar, sodass unruhige Verfolgung leicht zu erkennen ist.',
+    pointerPrompt: 'Gedrückt halten und im Zeichenbereich zeichnen',
+    samples: 'Proben',
+    jitterScore: 'Jitter',
+    snappingScore: 'Korrektur',
+    straightness: 'Geradheit',
+    rawDeviation: 'Durchschn. Abweichung',
+    statusIdle: 'Zeichne im Feld, um rohe Mausbewegung zu erfassen',
+    statusHealthy: 'Spur wirkt natürlich und stabil in den letzten Proben',
+    statusJitter: 'Verrauschte Bewegung in der letzten Spur erkannt',
+    statusSnapping: 'Verdächtig gerade Bewegung erkannt',
+    statusMixed: 'Sowohl Jitter als auch mögliche Winkelkorrektur erscheinen in der Spur',
+    reset: 'Zurücksetzen',
+    holdShift: 'Tipp: Ändere immer nur eine Sache. DPI, Oberfläche, Funkmodus und Vorhersage-Einstellungen können die Spur verändern.',
+    sensitivity: 'Erkennungsempfindlichkeit',
+    low: 'stabil',
+    high: 'streng',
+    traceLog: 'Spurereignisse',
+    emptyLog: 'Zeichne einige kontrollierte Striche, um das Ereignisprotokoll zu starten.',
+    jitterEvent: 'Jitter',
+    snappingEvent: 'Winkelkorrektur',
+    combinedEvent: 'Jitter und Winkelkorrektur',
+    cleanEvent: 'saubere Spur',
+    pxUnit: 'px',
+    percentUnit: '%',
+  },
+};