@jjlmoya/utils-hardware 1.17.0 → 1.19.0

package/src/tool/keyboardTest/keyboard-test.css

@@ -16,7 +16,15 @@
   --tt-kb-bg: #e2e8f0;
 
   width: 100%;
+  max-width: 100%;
   color: var(--tt-text);
+  overflow-x: clip;
+}
+
+.tt-wrapper *,
+.tt-wrapper *::before,
+.tt-wrapper *::after {
+  box-sizing: border-box;
 }
 
 .theme-dark .tt-wrapper {
@@ -58,6 +66,8 @@ body.is-widget .tt-wrapper > div {
       padding: 2rem;
       box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1);
       border: 1px solid var(--tt-border);
+      max-width: 100%;
+      overflow: hidden;
     }
 
     .tt-header {
@@ -167,7 +177,7 @@ body.is-widget .tt-wrapper > div {
     .tt-keyboard-wrapper {
       position: relative;
       width: 100%;
-      overflow-x: auto;
+      overflow: hidden;
       padding-bottom: 1rem;
       display: flex;
       justify-content: center;
@@ -181,7 +191,9 @@ body.is-widget .tt-wrapper > div {
       flex-direction: column;
       gap: 0.25rem;
       user-select: none;
+      width: 900px;
       min-width: 900px;
+      transform-origin: top center;
     }
 
     .tt-row {
@@ -323,4 +335,105 @@ body.is-widget .tt-wrapper > div {
       border-radius: 0.375rem;
       box-shadow: 0 1px 0 rgba(0, 0, 0, 0.1);
       flex-shrink: 0;
-    }
+    }
+
+    @media (max-width: 760px) {
+      .tt-container {
+        padding: 0;
+      }
+
+      body.is-widget .tt-wrapper > div {
+        padding: 0;
+      }
+
+      .tt-card {
+        border-radius: 0.875rem;
+        padding: 1rem;
+      }
+
+      .tt-header {
+        margin-bottom: 1rem;
+      }
+
+      .tt-title {
+        font-size: 1.5rem;
+      }
+
+      .tt-description {
+        font-size: 0.875rem;
+      }
+
+      .tt-stats {
+        display: grid;
+        grid-template-columns: 1fr auto;
+        width: 100%;
+        gap: 0.75rem;
+      }
+
+      .tt-stat-box {
+        min-width: 0;
+        padding: 0.75rem;
+        border-radius: 0.75rem;
+      }
+
+      .tt-stat-label {
+        font-size: 0.65rem;
+      }
+
+      .tt-stat-value {
+        font-size: 1.75rem;
+      }
+
+      .tt-reset-btn {
+        width: 3.5rem;
+        min-height: 100%;
+        border-radius: 0.75rem;
+      }
+
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.82;
+
+        min-height: calc(20rem * var(--tt-keyboard-scale));
+        padding-bottom: 0;
+        align-items: flex-start;
+      }
+
+      .tt-keyboard {
+        transform: scale(var(--tt-keyboard-scale));
+        margin-bottom: calc((20rem * var(--tt-keyboard-scale)) - 20rem);
+      }
+
+      .tt-event-log {
+        height: 2.25rem;
+      }
+    }
+
+    @media (max-width: 680px) {
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.72;
+      }
+    }
+
+    @media (max-width: 600px) {
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.62;
+      }
+    }
+
+    @media (max-width: 520px) {
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.52;
+      }
+    }
+
+    @media (max-width: 440px) {
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.42;
+      }
+    }
+
+    @media (max-width: 360px) {
+      .tt-keyboard-wrapper {
+        --tt-keyboard-scale: 0.36;
+      }
+    }

package/src/tool/mouseDoubleClickTest/bibliography.astro

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

package/src/tool/mouseDoubleClickTest/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'UI Events: click and dblclick event definitions',
+    url: 'https://www.w3.org/TR/uievents/',
+  },
+  {
+    name: 'MDN Web Docs: Element click event',
+    url: 'https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event',
+  },
+  {
+    name: 'MDN Web Docs: performance.now()',
+    url: 'https://developer.mozilla.org/en-US/docs/Web/API/Performance/now',
+  },
+];

package/src/tool/mouseDoubleClickTest/component.astro

@@ -0,0 +1,135 @@
+---
+import type { KnownLocale } from '../../types';
+import type { MouseDoubleClickTestUI } from './ui';
+import { Icon } from 'astro-icon/components';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as MouseDoubleClickTestUI;
+---
+
+<div class="mdct-root" id="mdct-root" data-config={JSON.stringify({
+  statusIdle: t.statusIdle,
+  statusClean: t.statusClean,
+  statusWarning: t.statusWarning,
+  emptyLog: t.emptyLog,
+  leftButton: t.leftButton,
+  middleButton: t.middleButton,
+  rightButton: t.rightButton,
+  backButton: t.backButton,
+  forwardButton: t.forwardButton,
+  otherButton: t.otherButton,
+  thresholdUnit: t.thresholdUnit,
+  cleanEvent: t.cleanEvent,
+  suspiciousEvent: t.suspiciousEvent,
+})}>
+  <section class="mdct-card">
+    <div class="mdct-stage">
+      <button id="mdct-target" class="mdct-target" type="button">
+        <span class="mdct-mouse" aria-hidden="true">
+          <span class="mdct-cable"></span>
+          <span class="mdct-button mdct-left" data-button="left" data-label={t.leftButton}></span>
+          <span class="mdct-button mdct-right" data-button="right" data-label={t.rightButton}></span>
+          <span class="mdct-button mdct-middle" data-button="middle" data-label={t.middleButton}></span>
+          <span class="mdct-button mdct-back" data-button="back" data-label={t.backButton}></span>
+          <span class="mdct-button mdct-forward" data-button="forward" data-label={t.forwardButton}></span>
+          <span class="mdct-palm"></span>
+        </span>
+        <span class="mdct-target-copy">
+          <span class="mdct-target-kicker">
+            <Icon name="mdi:mouse" class="mdct-target-icon" />
+            {t.badge}
+          </span>
+          <strong>{t.clickTarget}</strong>
+          <small>{t.clickTargetHint}</small>
+        </span>
+      </button>
+
+      <div class="mdct-dashboard">
+        <div class="mdct-readout">
+          <span>{t.healthScore}</span>
+          <strong id="mdct-score">100%</strong>
+          <small id="mdct-status" data-state="clean">{t.statusIdle}</small>
+        </div>
+
+        <div class="mdct-metrics">
+          <div class="mdct-metric mdct-metric-total">
+            <span>{t.totalClicks}</span>
+            <strong id="mdct-total">0</strong>
+          </div>
+          <div class="mdct-metric mdct-metric-alert">
+            <span>{t.suspiciousClicks}</span>
+            <strong id="mdct-suspicious">0</strong>
+          </div>
+        </div>
+
+        <label class="mdct-threshold">
+          <span>{t.thresholdLabel}</span>
+          <b><span id="mdct-threshold-value">80</span> {t.thresholdUnit}</b>
+          <input id="mdct-threshold" type="range" min="30" max="180" value="80" step="5" />
+        </label>
+
+        <div class="mdct-speed-row">
+          <div>
+            <span>{t.fastestGap}</span>
+            <strong id="mdct-fastest">--</strong>
+          </div>
+          <div>
+            <span>{t.lastGap}</span>
+            <strong id="mdct-last-gap">--</strong>
+          </div>
+        </div>
+
+        <div class="mdct-log-head">
+          <span>{t.logTitle}</span>
+          <button id="mdct-reset" class="mdct-reset" type="button">{t.reset}</button>
+        </div>
+        <ol id="mdct-log" class="mdct-log"></ol>
+      </div>
+    </div>
+  </section>
+</div>
+
+<script>
+  import { MouseDoubleClickTester } from './logic';
+
+  const root = document.getElementById('mdct-root');
+  const labels = JSON.parse(root?.dataset.config ?? '{}');
+  const buttons = root?.querySelectorAll<HTMLElement>('.mdct-button') ?? document.querySelectorAll<HTMLElement>('.mdct-button');
+
+  new MouseDoubleClickTester(
+    {
+      target: document.getElementById('mdct-target'),
+      total: document.getElementById('mdct-total'),
+      suspicious: document.getElementById('mdct-suspicious'),
+      fastest: document.getElementById('mdct-fastest'),
+      score: document.getElementById('mdct-score'),
+      status: document.getElementById('mdct-status'),
+      threshold: document.getElementById('mdct-threshold') as HTMLInputElement | null,
+      thresholdValue: document.getElementById('mdct-threshold-value'),
+      lastGap: document.getElementById('mdct-last-gap'),
+      log: document.getElementById('mdct-log'),
+      reset: document.getElementById('mdct-reset'),
+      buttons,
+    },
+    {
+      statusIdle: labels.statusIdle,
+      statusClean: labels.statusClean,
+      statusWarning: labels.statusWarning,
+      emptyLog: labels.emptyLog,
+      leftButton: labels.leftButton,
+      middleButton: labels.middleButton,
+      rightButton: labels.rightButton,
+      backButton: labels.backButton,
+      forwardButton: labels.forwardButton,
+      otherButton: labels.otherButton,
+      thresholdUnit: labels.thresholdUnit,
+      cleanEvent: labels.cleanEvent,
+      suspiciousEvent: labels.suspiciousEvent,
+    },
+  );
+</script>

package/src/tool/mouseDoubleClickTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+
+import type { MouseDoubleClickTestUI } from './ui';
+export type MouseDoubleClickTestLocaleContent = ToolLocaleContent<MouseDoubleClickTestUI>;
+
+export const mouseDoubleClickTest: HardwareToolEntry<MouseDoubleClickTestUI> = {
+  id: 'mouse-double-click-test',
+  icons: {
+    bg: 'mdi:mouse',
+    fg: 'mdi:gesture-tap-button',
+  },
+  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/mouseDoubleClickTest/i18n/de.ts

@@ -0,0 +1,274 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { MouseDoubleClickTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'maus-doppelklick-test';
+const title = 'Maus Doppelklick Test';
+const description =
+  'Testen Sie jede Maustaste und erkennen Sie unerwünschte Doppelklicks, verschlissene Schalter und Kontaktprellen mit zeitgenauer Aufzeichnung pro Taste in Ihrem Browser.';
+
+const faqData = [
+  {
+    question: 'Was ist ein Maus-Doppelklick-Problem?',
+    answer:
+      'Ein Doppelklick-Problem tritt auf, wenn ein physischer Tastendruck als zwei Klicks gemeldet wird. Es kann die linke Taste, die rechte Taste, den Radklick oder die Seitentasten betreffen und wird meist durch Schalterverschleiß, Kontaktprellen, Firmware-Entprellungseinstellungen oder drahtlose Signalinstabilität verursacht.',
+  },
+  {
+    question: 'Welcher Abstand gilt als verdächtig?',
+    answer:
+      'Sehr kurze Abstände zwischen Klicks sind verdächtig, da menschliche Doppelklicks normalerweise mehr Zeit benötigen. Dieses Tool startet mit einem Schwellenwert von 80 ms, den Sie je nach Maus und Teststil anpassen können.',
+  },
+  {
+    question: 'Kann ein Browser beweisen, dass der Schalter defekt ist?',
+    answer:
+      'Ein Browser kann den elektrischen Schalter nicht direkt prüfen, aber er kann die Klickereignisse aufzeichnen, die Ihr Betriebssystem empfängt. Wiederholte verdächtige Abstände während eines Einzelklick-Tests sind starke Hinweise auf Prellen oder unerwünschtes Doppelklicken.',
+  },
+  {
+    question: 'Wie sollte ich richtig testen?',
+    answer:
+      'Klicken Sie langsam und bewusst und zielen Sie auf einzelne Tastendrücke ab. Wenn der Verdächtig-Zähler auch dann steigt, wenn Sie nicht absichtlich doppelklicken, wiederholen Sie den Test an einem anderen USB-Anschluss, einem anderen Browser und wenn möglich an einem anderen Computer.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Erkennungsschwelle einstellen',
+    text: 'Beginnen Sie mit 80 ms. Senken Sie den Wert für eine strenge Prellungserkennung oder erhöhen Sie ihn, wenn Ihr Gerät etwas breitere versehentliche Abstände erzeugt.',
+  },
+  {
+    name: 'Wie ein normaler Einzelklick klicken',
+    text: 'Drücken Sie jede Maustaste einzeln über der Mausgrafik. Klicken Sie beim ersten Durchlauf nicht absichtlich doppelt.',
+  },
+  {
+    name: 'Verdächtig-Zähler beobachten',
+    text: 'Wenn während des Einfachklickens verdächtige Ereignisse auftreten, prüfen Sie, welche visuelle Taste hervorgehoben wurde, und vergleichen Sie dies mit den kompakten Ereignischips.',
+  },
+  {
+    name: 'Mit einem anderen Gerät vergleichen',
+    text: 'Eine gesunde Maus sollte bei gleichem Schwellenwert eine hohe Punktzahl behalten. Der Vergleich von Geräten hilft, Hardwarefehler von Softwareeinstellungen zu unterscheiden.',
+  },
+];
+
+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<MouseDoubleClickTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    {
+      type: 'title',
+      text: 'Maus Doppelklick Test: Tastenprellen online diagnostizieren',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine Maus, die bei einmaligem Drücken doppelt klickt, ist nicht nur ärgerlich. Sie kann versehentlich Ordner öffnen, Drag-and-Drop-Aktionen abbrechen, in Spielen zwei Schüsse abfeuern, Browser-Tabs schließen oder Kontextmenüs erscheinen und verschwinden lassen, bevor Sie sie nutzen können. Dieser Online-Maus-Doppelklick-Test konzentriert sich auf das nützliche Diagnosesignal: <strong>den zeitlichen Abstand zwischen den von Ihrem Betriebssystem gemeldeten Tastenereignissen</strong>.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Anders als ein einfacher Klick-Zähler verfolgt dieses Tool jede Taste unabhängig: linker Klick, rechter Klick, Radklick, Browser-Zurück und Browser-Vorwärts. Das ist wichtig, denn eine Maus kann eine defekte rechte Taste haben, während die linke noch funktioniert, oder eine abgenutzte Seitentaste, die erst nach Monaten des Gamings oder der Nutzung von Produktivitäts-Shortcuts Fehlauslösungen zeigt.',
+    },
+    {
+      type: 'title',
+      text: 'Was dieser Maustasten-Test misst',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Wenn Sie eine Maustaste drücken, empfängt der Browser ein Pointer-Ereignis mit dem Tastencode. Das Tool speichert den letzten Zeitstempel für dieselbe physische Taste und vergleicht ihn mit dem nächsten Druck derselben Taste. Ist der Abstand kürzer als Ihr gewählter Schwellenwert, wird das Ereignis als verdächtig markiert, da ein normaler beabsichtigter zweiter Klick in der Regel länger dauert.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Linke Taste: nützlich zur Erkennung versehentlicher Doppelklicks beim Öffnen von Dateien, Markieren von Text oder Verschieben von Fenstern',
+        'Rechte Taste: nützlich, wenn Kontextmenüs flackern, doppelt erscheinen oder sofort schließen',
+        'Radklick: nützlich bei Mäusen, bei denen der Mittelklick mehrere Tabs öffnet oder nach intensiver Nutzung ausfällt',
+        'Zurück- und Vorwärtstasten: nützlich für Gaming-Mäuse und Produktivitätsmäuse mit Seitenschaltern',
+        'Zeitmessung pro Taste: vermeidet, einen Linksklick mit einem Rechtsklick zu vermischen und als falschen Doppelklick zu werten',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum Mäuse anfangen doppelt zu klicken',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die meisten Mäuse verwenden kleine mechanische Schalter unter jeder Taste. Wenn die Schaltkontakte schließen, kann das Metall für einen sehr kurzen Zeitraum elektrisch prellen, bevor es sich setzt. Die Maus-Firmware filtert dieses Rauschen normalerweise mit einer Entprell-Logik. Wenn der Schalter verschleißt, kann das Prellen länger, lauter oder inkonsistenter werden, sodass der Computer zwei Tastendrücke empfängt, obwohl Ihr Finger nur einen physischen Druck ausgeführt hat.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Doppelklicken wird nicht immer durch dasselbe verursacht. Es kann mechanischer Schalterverschleiß, zu aggressiv eingestellte Firmware-Entprellung, Staub oder Oxidation im Schalter, drahtlose Paketinstabilität, Makro-Software, ein beschädigtes Kabel oder eine Betriebssystemeinstellung sein, die versehentliche Doppelklicks auffälliger macht.',
+    },
+    {
+      type: 'table',
+      headers: ['Symptom', 'Wahrscheinliche Ursache', 'Was zu testen ist'],
+      rows: [
+        ['Ein Klick öffnet Dateien, als wäre doppelt geklickt worden', 'Linkes Schalterprellen oder Verwechslung der Doppelklick-Geschwindigkeit im Betriebssystem', 'Linke Taste mit langsamen Einzeldrücken bei 80 ms testen'],
+        ['Rechtsklick-Menü flackert oder schließt sich', 'Rechtes Schalterprellen oder Software, die Kontextmenüs abfängt', 'Rechte Taste testen und Maus-Dienstprogramme vorübergehend deaktivieren'],
+        ['Mittelklick öffnet zwei Tabs', 'Radschalter-Verschleiß', 'Radklick mit bewussten Einzeldrücken testen'],
+        ['Zurück-Taste springt zwei Seiten zurück', 'Seitenschalter-Prellen oder Browser-Shortcut-Wiederholung', 'Zurück und Vorwärts separat testen'],
+        ['Tritt nur drahtlos auf', 'Drahtlose Interferenz, niedriger Akku oder Empfängerplatzierung', 'Kabelgebunden erneut testen oder Empfänger näher platzieren'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Den richtigen Entprell-Schwellenwert wählen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Schwellenwert ist der maximale Abstand, den dieses Tool noch als verdächtig betrachtet. Der Standardwert <strong>80 ms</strong> ist ein praktischer Mittelweg: streng genug, um viele unerwünschte doppelte Ereignisse zu erkennen, aber nicht so aggressiv, dass jeder normale absichtliche Doppelklick zu einem Hardwarefehler wird.',
+    },
+    {
+      type: 'table',
+      headers: ['Schwellenwert', 'Am besten geeignet für', 'Wie zu interpretieren'],
+      rows: [
+        ['30-50 ms', 'Strenge elektrische Prellungsprüfungen', 'Gut zur Bestätigung sehr schneller doppelter Ereignisse von einem verschlissenen Schalter'],
+        ['60-90 ms', 'Allgemeine Maus-Doppelklick-Diagnose', 'Bester Standardbereich für die meisten Gaming- und Büromäuse'],
+        ['100-140 ms', 'Intermittierende verschlissene Schalter', 'Nützlich, wenn die Maus gelegentlich breitere versehentliche Abstände erzeugt'],
+        ['150-180 ms', 'Stresstest und schwache Schalter', 'Vorsichtig verwenden, da schnelle absichtliche Doppelklicks in diesen Bereich fallen können'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'So führen Sie einen zuverlässigen Test durch',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Klicken Sie beim ersten Durchlauf nicht absichtlich doppelt. Drücken Sie jede Maustaste langsam und bewusst, eine Taste nach der anderen, während sich der Cursor über der Mausgrafik befindet. Ein gesunder Schalter sollte stabile Einzelereignisse erzeugen. Wenn der Verdächtig-Zähler bei langsamen Einzeldrücken steigt, wiederholen Sie denselben Tastentest mehrmals, um das Muster zu bestätigen.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Testen Sie die linke Taste mit 20 bis 30 langsamen Drücken, dann die rechte, dann das Rad, dann die Seitentasten',
+        'Ziehen Sie die Maus nicht während des Prell-Tests, da Bewegung das Zeitergebnis beeinträchtigen kann',
+        'Wenn eine Taste verdächtige Ereignisse zeigt, wiederholen Sie denselben Test nach dem Wechsel des USB-Anschlusses oder Browsers',
+        'Testen Sie drahtlose Mäuse mit einer frischen Batterie und dem Empfänger nahe an der Maus',
+        'Wenn nur eine Taste wiederholt ausfällt, liegt der Fehler wahrscheinlich an diesem spezifischen Schalter und nicht am gesamten Gerät',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Ergebnisse interpretieren',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Ergebnis', 'Bedeutung', 'Empfohlener nächster Schritt'],
+      rows: [
+        ['0 verdächtige Ereignisse nach vielen Drücken', 'Die getesteten Tasten erscheinen unter dem gewählten Schwellenwert gesund', 'Behalten Sie den Standardschwellenwert bei oder testen Sie später erneut, wenn Symptome zurückkehren'],
+        ['1 isoliertes verdächtiges Ereignis', 'Könnte ein echtes Prellen oder ein versehentlich schneller Druck sein', 'Dieselbe Taste langsam wiederholen, bevor Sie Schlüsse ziehen'],
+        ['Wiederholte verdächtige Ereignisse bei einer Taste', 'Starkes Anzeichen für Schalterprellen oder verschlissene Kontakte', 'An einem anderen Computer testen und das Ergebnis dokumentieren'],
+        ['Verdächtige Ereignisse bei jeder Taste', 'Könnte Software, Treiber, Makro-Dienstprogramm oder Browser-Umgebung sein', 'Maus-Software deaktivieren und erneut testen'],
+        ['Nur der drahtlose Modus schlägt fehl', 'Wahrscheinlich Akku, Empfängerplatzierung oder Interferenz', 'Kabelgebundenen Modus versuchen oder Empfänger näher platzieren'],
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Gesundheitswert ist eine schnelle Zusammenfassung, kein endgültiges Urteil. Der wichtigste Beweis ist <strong>welche Taste</strong> verdächtige Ereignisse erzeugt hat und ob sich das Muster wiederholt, wenn Sie genau diese Taste langsam drücken. Ein einzelnes schlechtes Ereignis während eines hastigen Tests ist weniger aussagekräftig als fünf verdächtige Rechtsklick-Ereignisse während bewusster Einzeldrücke.',
+    },
+    {
+      type: 'title',
+      text: 'Bevor Sie die Maus ersetzen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Prüfen Sie, ob Ihre Maus-Software eine Einstellung für die Entprellzeit hat, und testen Sie nach der Änderung erneut',
+        'Deaktivieren Sie Makros, Rapid-Fire-Profile oder Tasten-Neubelegungen während der Diagnose',
+        'Versuchen Sie einen anderen USB-Anschluss, insbesondere wenn Sie einen Hub oder Frontpanel-Anschluss verwenden',
+        'Testen Sie drahtlose Mäuse mit dem Dongle an einem Verlängerungskabel nahe am Mauspad',
+        'Vergleichen Sie mit einer anderen Maus am selben Computer, um Hardwarefehler von Softwareverhalten zu unterscheiden',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Reparatur, Garantie und Beweise',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Wenn der Fehler mechanisch ist, behebt eine Reinigung des Außengehäuses das Problem selten dauerhaft, da das Problem im Inneren der Schaltkontakte liegt. Einige Benutzer tauschen den Mikroschalter aus, aber das erfordert Löten und lohnt sich nicht für jede Maus. Wenn die Maus unter Garantie steht, sind wiederholte verdächtige Abstände bei derselben Taste nützliche Beweise, um das Problem dem Support zu erklären.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Für Garantieansprüche zeichnen Sie eine kurze Bildschirmaufnahme auf, während Sie die defekte Taste langsam drücken. Stellen Sie sicher, dass die Ereignischips die Tastenbezeichnung und die verdächtige Zeit zeigen. Das ist klarer als "meine Maus klickt manchmal doppelt", da es die tatsächliche Taste und die ungefähre Zeit des unerwünschten doppelten Ereignisses demonstriert.',
+    },
+    {
+      type: 'title',
+      text: 'Einschränkungen eines browserbasierten Maus-Tests',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieser Test misst die Ereignisse, die den Browser erreichen. Er kann die elektrische Wellenform im Schalter nicht direkt prüfen und er kann nicht jeden Treiber, jedes Betriebssystem oder jedes Hersteller-Dienstprogramm umgehen. Das ist trotzdem nützlich: Wenn der Browser doppelte Ereignisse empfängt, können Ihre normalen Anwendungen sie ebenfalls empfangen. Für eine technische Validierung auf Ingenieursniveau liefern Hardware-Tools wie Oszilloskope oder Schaltertester tiefere Erkenntnisse, sind aber für die meisten Benutzerdiagnosen nicht erforderlich.',
+    },
+  ],
+  ui: {
+    badge: 'Schalter-Prell-Labor',
+    clickTarget: 'Tastenmatrix',
+    clickTargetHint: 'Links, rechts, Rad, zurück und vorwärts drücken',
+    totalClicks: 'Gesamt',
+    suspiciousClicks: 'Verdächtig',
+    fastestGap: 'Schnellster Abstand',
+    healthScore: 'Gesundheitswert',
+    thresholdLabel: 'Erkennungsschwelle',
+    thresholdUnit: 'ms',
+    cleanEvent: 'sauber',
+    suspiciousEvent: 'verdächtig',
+    reset: 'Zurücksetzen',
+    statusIdle: 'Drücken Sie jede Maustaste, um sie unabhängig zu testen',
+    statusClean: 'Kein verdächtiges Tastenprellen erkannt',
+    statusWarning: 'Verdächtiges Prellen an einer Maustaste erkannt',
+    lastGap: 'Letztes Ereignis',
+    logTitle: 'Letzte Tastenereignisse',
+    emptyLog: 'Drücken Sie eine beliebige Maustaste über dem Mauskörper.',
+    leftButton: 'Links',
+    middleButton: 'Rad',
+    rightButton: 'Rechts',
+    backButton: 'Zurück',
+    forwardButton: 'Vorwärts',
+    otherButton: 'Andere',
+  },
+};