@jjlmoya/utils-hardware 1.27.0 → 1.28.0

package/package.json

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

package/src/category/index.ts

@@ -17,10 +17,11 @@ import { webBluetoothBleScanner } from '../tool/webBluetoothBleScanner/index';
 import { keyboardChatterTest } from '../tool/keyboardChatterTest/index';
 import { webUsbSerialMonitor } from '../tool/webUsbSerialMonitor/index';
 import { usbPowerBudgetCalculator } from '../tool/usbPowerBudgetCalculator/index';
+import { mobileSensorTest } from '../tool/mobileSensorTest/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
+  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, 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

@@ -34,6 +34,8 @@ export { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
 export type { WebUsbSerialMonitorLocaleContent } from './tool/webUsbSerialMonitor/entry';
 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 { hardwareCategory } from './category';
 import { estimadorSaludBateria } from './tool/batteryHealthEstimator/entry';
 import { pixelesPantalla } from './tool/deadPixelTest/entry';
@@ -53,4 +55,5 @@ import { webBluetoothBleScanner } from './tool/webBluetoothBleScanner/entry';
 import { keyboardChatterTest } from './tool/keyboardChatterTest/entry';
 import { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
 import { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];
+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];

package/src/index.ts

@@ -35,3 +35,4 @@ export { WEB_BLUETOOTH_BLE_SCANNER_TOOL } from './tool/webBluetoothBleScanner/in
 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';

package/src/tests/locale_completeness.test.ts

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

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(18);
+      expect(ALL_TOOLS.length).toBe(19);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/mobileSensorTest/bibliography.astro

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

package/src/tool/mobileSensorTest/bibliography.ts

@@ -0,0 +1,24 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Apple Support - Calibrate the compass on iPhone',
+    url: 'https://support.apple.com/guide/iphone/iph1ac0b663/ios',
+  },
+  {
+    name: 'Android Developers - Position sensors',
+    url: 'https://developer.android.com/develop/sensors-and-location/sensors/sensors_position',
+  },
+  {
+    name: 'Android Developers - Motion sensors',
+    url: 'https://developer.android.com/develop/sensors-and-location/sensors/sensors_motion',
+  },
+  {
+    name: 'W3C - Motion Sensors Explainer',
+    url: 'https://www.w3.org/TR/motion-sensors/',
+  },
+  {
+    name: 'WebKit - DeviceMotion and DeviceOrientation permission policy',
+    url: 'https://webkit.org/blog/10218/full-third-party-cookie-blocking-and-more/',
+  },
+];

package/src/tool/mobileSensorTest/component.astro

@@ -0,0 +1,241 @@
+---
+import type { KnownLocale } from '../../types';
+import type { MobileSensorTestUI } from './ui';
+import './mobile-sensor-test.css';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as MobileSensorTestUI;
+const strings = JSON.stringify(t);
+---
+
+<div class="mst-shell" id="mst-root" data-ui={strings} data-state="ready">
+  <div class="mst-stage">
+    <div class="mst-privacy">
+      <strong>{t.privacyBadge}</strong>
+      <span>{t.privacyCopy}</span>
+    </div>
+
+    <button class="mst-start" type="button" id="mst-start">
+      <span>{t.startButton}</span>
+      <small>{t.permissionHint}</small>
+    </button>
+
+    <div class="mst-status" id="mst-status">{t.statusReady}</div>
+
+    <div class="mst-orbit" aria-label={t.cubeLabel}>
+      <div class="mst-cube" id="mst-cube">
+        <span class="mst-face mst-face-front"></span>
+        <span class="mst-face mst-face-back"></span>
+        <span class="mst-face mst-face-right"></span>
+        <span class="mst-face mst-face-left"></span>
+        <span class="mst-face mst-face-top"></span>
+        <span class="mst-face mst-face-bottom"></span>
+      </div>
+    </div>
+  </div>
+
+  <div class="mst-panels">
+    <section class="mst-panel mst-bubble-card">
+      <div class="mst-panel-top">
+        <span>{t.bubblePanel}</span>
+        <strong id="mst-stability">{t.steadyLabel}</strong>
+      </div>
+      <div class="mst-bubble" aria-label={t.bubbleLabel}>
+        <span id="mst-bubble-dot"></span>
+        <i></i>
+        <b></b>
+      </div>
+      <div class="mst-readout">
+        <span>{t.levelOffsetLabel}</span>
+        <strong id="mst-level"></strong>
+      </div>
+    </section>
+
+    <section class="mst-panel">
+      <div class="mst-panel-top">
+        <span>{t.orientationPanel}</span>
+        <strong>{t.calibrationLabel}</strong>
+      </div>
+      <div class="mst-axis-grid">
+        <div><span>{t.alphaLabel}</span><strong id="mst-alpha"></strong></div>
+        <div><span>{t.betaLabel}</span><strong id="mst-beta"></strong></div>
+        <div><span>{t.gammaLabel}</span><strong id="mst-gamma"></strong></div>
+      </div>
+    </section>
+
+    <section class="mst-panel">
+      <div class="mst-panel-top">
+        <span>{t.motionPanel}</span>
+        <strong id="mst-motion-total"></strong>
+      </div>
+      <div class="mst-bars">
+        <label><span>{t.accelXLabel}</span><i><b id="mst-accel-x"></b></i><strong id="mst-accel-x-value"></strong></label>
+        <label><span>{t.accelYLabel}</span><i><b id="mst-accel-y"></b></i><strong id="mst-accel-y-value"></strong></label>
+        <label><span>{t.accelZLabel}</span><i><b id="mst-accel-z"></b></i><strong id="mst-accel-z-value"></strong></label>
+      </div>
+      <div class="mst-rotation-grid">
+        <div><span>{t.rotationAlphaLabel}</span><strong id="mst-rot-alpha"></strong></div>
+        <div><span>{t.rotationBetaLabel}</span><strong id="mst-rot-beta"></strong></div>
+        <div><span>{t.rotationGammaLabel}</span><strong id="mst-rot-gamma"></strong></div>
+      </div>
+    </section>
+  </div>
+
+  <script>
+    import { assessMobileSensors, clamp, safeNumber } from './logic';
+
+    const root = document.getElementById('mst-root') as HTMLElement | null;
+    const ui = JSON.parse(root?.dataset.ui ?? '{}') as Record<string, string>;
+    const startButton = document.getElementById('mst-start') as HTMLButtonElement | null;
+    const status = document.getElementById('mst-status');
+    const cube = document.getElementById('mst-cube') as HTMLElement | null;
+    const bubble = document.getElementById('mst-bubble-dot') as HTMLElement | null;
+    const stability = document.getElementById('mst-stability');
+    const fields = {
+      alpha: document.getElementById('mst-alpha'),
+      beta: document.getElementById('mst-beta'),
+      gamma: document.getElementById('mst-gamma'),
+      level: document.getElementById('mst-level'),
+      motionTotal: document.getElementById('mst-motion-total'),
+      accelX: document.getElementById('mst-accel-x') as HTMLElement | null,
+      accelY: document.getElementById('mst-accel-y') as HTMLElement | null,
+      accelZ: document.getElementById('mst-accel-z') as HTMLElement | null,
+      accelXValue: document.getElementById('mst-accel-x-value'),
+      accelYValue: document.getElementById('mst-accel-y-value'),
+      accelZValue: document.getElementById('mst-accel-z-value'),
+      rotAlpha: document.getElementById('mst-rot-alpha'),
+      rotBeta: document.getElementById('mst-rot-beta'),
+      rotGamma: document.getElementById('mst-rot-gamma'),
+    };
+
+    const snapshot = {
+      alpha: 0,
+      beta: 0,
+      gamma: 0,
+      accelerationX: 0,
+      accelerationY: 0,
+      accelerationZ: 0,
+      rotationAlpha: 0,
+      rotationBeta: 0,
+      rotationGamma: 0,
+    };
+
+    function setText(el: HTMLElement | null, value: string) {
+      if (el) el.textContent = value;
+    }
+
+    function setState(state: string, label: string) {
+      if (root) root.dataset.state = state;
+      setText(status, label);
+    }
+
+    function formatDegrees(value: number) {
+      return `${value.toFixed(1)} deg`;
+    }
+
+    function setBar(el: HTMLElement | null, value: number) {
+      if (!el) return;
+      const width = clamp(Math.abs(value) / 24 * 100, 2, 100);
+      el.style.width = `${width}%`;
+      el.style.transform = value < 0 ? 'scaleX(-1)' : 'scaleX(1)';
+    }
+
+    function render() {
+      const assessment = assessMobileSensors(snapshot);
+      const bubbleX = clamp(snapshot.gamma / 45 * 50, -42, 42);
+      const bubbleY = clamp(snapshot.beta / 45 * 50, -42, 42);
+      const stabilityText = ui[`${assessment.stability}Label`] ?? ui.steadyLabel ?? '';
+
+      setText(fields.alpha, formatDegrees(snapshot.alpha));
+      setText(fields.beta, formatDegrees(snapshot.beta));
+      setText(fields.gamma, formatDegrees(snapshot.gamma));
+      setText(fields.level, formatDegrees(assessment.levelOffset));
+      setText(fields.motionTotal, `${assessment.motionMagnitude.toFixed(1)} m/s2`);
+      setText(fields.accelXValue, snapshot.accelerationX.toFixed(1));
+      setText(fields.accelYValue, snapshot.accelerationY.toFixed(1));
+      setText(fields.accelZValue, snapshot.accelerationZ.toFixed(1));
+      setText(fields.rotAlpha, snapshot.rotationAlpha.toFixed(1));
+      setText(fields.rotBeta, snapshot.rotationBeta.toFixed(1));
+      setText(fields.rotGamma, snapshot.rotationGamma.toFixed(1));
+      setText(stability, stabilityText);
+      setBar(fields.accelX, snapshot.accelerationX);
+      setBar(fields.accelY, snapshot.accelerationY);
+      setBar(fields.accelZ, snapshot.accelerationZ);
+
+      if (bubble) bubble.style.transform = `translate(calc(-50% + ${bubbleX}px), calc(-50% + ${bubbleY}px))`;
+      if (cube) cube.style.transform = `rotateZ(${snapshot.alpha}deg) rotateX(${snapshot.beta}deg) rotateY(${snapshot.gamma}deg)`;
+    }
+
+    function onOrientation(event: DeviceOrientationEvent) {
+      snapshot.alpha = safeNumber(event.alpha);
+      snapshot.beta = safeNumber(event.beta);
+      snapshot.gamma = safeNumber(event.gamma);
+      render();
+    }
+
+    function onMotion(event: DeviceMotionEvent) {
+      snapshot.accelerationX = safeNumber(event.accelerationIncludingGravity?.x);
+      snapshot.accelerationY = safeNumber(event.accelerationIncludingGravity?.y);
+      snapshot.accelerationZ = safeNumber(event.accelerationIncludingGravity?.z);
+      snapshot.rotationAlpha = safeNumber(event.rotationRate?.alpha);
+      snapshot.rotationBeta = safeNumber(event.rotationRate?.beta);
+      snapshot.rotationGamma = safeNumber(event.rotationRate?.gamma);
+      render();
+    }
+
+    function hasSensorSupport() {
+      return 'DeviceOrientationEvent' in window || 'DeviceMotionEvent' in window;
+    }
+
+    async function requestEventPermission(eventConstructor: unknown): Promise<PermissionState> {
+      const eventWithPermission = eventConstructor as { requestPermission?: () => Promise<PermissionState> };
+      if (typeof eventWithPermission.requestPermission !== 'function') return 'granted';
+      return eventWithPermission.requestPermission();
+    }
+
+    async function requestRequiredPermissions() {
+      const orientationPermission = await requestEventPermission(window.DeviceOrientationEvent);
+      const motionPermission = await requestEventPermission(window.DeviceMotionEvent);
+
+      return orientationPermission === 'granted' && motionPermission === 'granted';
+    }
+
+    function activateSensors() {
+      window.addEventListener('deviceorientation', onOrientation);
+      window.addEventListener('devicemotion', onMotion);
+      startButton?.setAttribute('disabled', 'true');
+      setState('active', ui.statusActive ?? '');
+    }
+
+    async function requestSensorAccess() {
+      if (!hasSensorSupport()) {
+        setState('unsupported', ui.statusUnsupported ?? '');
+        return;
+      }
+
+      setState('waiting', ui.statusWaiting ?? '');
+
+      try {
+        if (!(await requestRequiredPermissions())) {
+          setState('denied', ui.statusDenied ?? '');
+          return;
+        }
+
+        activateSensors();
+      } catch {
+        setState('denied', ui.statusDenied ?? '');
+      }
+    }
+
+    startButton?.addEventListener('click', () => {
+      void requestSensorAccess();
+    });
+
+    render();
+  </script>
+</div>

package/src/tool/mobileSensorTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { MobileSensorTestUI } from './ui';
+
+export type MobileSensorTestLocaleContent = ToolLocaleContent<MobileSensorTestUI>;
+
+export const mobileSensorTest: HardwareToolEntry<MobileSensorTestUI> = {
+  id: 'mobile-sensor-test',
+  icons: {
+    bg: 'mdi:cellphone-cog',
+    fg: 'mdi:axis-arrow',
+  },
+  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/mobileSensorTest/i18n/de.ts

@@ -0,0 +1,186 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { MobileSensorTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'mobiler-sensor-test';
+const title = 'Mobiler Sensor Test';
+const description = 'Führen Sie einen Online-Test für Gyroskop, Beschleunigungssensor, Bewegungssensor und digitale Wasserwaage auf Ihrem Handy durch, um Neigung, Drehung, Drift und Sensor-Kalibrierungsprobleme zu überprüfen.';
+
+const faqData = [
+  {
+    question: 'Wie kann ich mein Handy-Gyroskop online testen?',
+    answer: 'Öffnen Sie den Test auf dem Handy, tippen Sie auf Kalibrierung starten, erlauben Sie bei Aufforderung den Zugriff auf die Bewegungssensoren und drehen und neigen Sie dann das Gerät. Ein funktionierendes Gyroskop und ein Orientierungssensor sollten Alpha, Beta und Gamma gleichmäßig aktualisieren, ohne einzufrieren oder wild zu springen.',
+  },
+  {
+    question: 'Kann ich den Beschleunigungssensor mit einer Wasserwaage testen?',
+    answer: 'Ja. Legen Sie das Handy nach dem Start des Tests auf einen flachen Tisch. Die Blase sollte sich nahe der Mitte einpendeln und die Beschleunigungswerte sollten stabil bleiben. Wenn die Blase stark driftet, während das Handy still liegt, muss der Beschleunigungssensor möglicherweise kalibriert werden oder die Hülle, der Tisch oder die Gerätehardware stören.',
+  },
+  {
+    question: 'Warum fragt das iPhone nach Bewegungserlaubnis?',
+    answer: 'Safari auf iPhone und iPad erfordert eine Berührung, bevor Websites auf Bewegungs- und Orientierungssensoren zugreifen können. Wenn die Erlaubnis verweigert wird, kann der Test keine Gyroskop- oder Beschleunigungsdaten lesen, bis Sie den Bewegungszugriff erlauben.',
+  },
+  {
+    question: 'Kann dies einen defekten Kompass reparieren oder kalibrieren?',
+    answer: 'Kein Browser-Tool kann Hardware reparieren oder die System-Kompasskalibrierung erzwingen. Dieser Test hilft Ihnen, Symptome zu erkennen: eingefrorene Messwerte, verrauschtes Signal, Drift, fehlende Berechtigungen oder einen Browser, der die Sensoren nicht bereitstellt.',
+  },
+];
+
+const howToData = [
+  { name: 'Öffnen Sie den Test auf Ihrem Handy', text: 'Verwenden Sie dasselbe iPhone, iPad, Android-Handy oder Tablet, das Sie diagnostizieren möchten. Desktop-Browser haben in der Regel keine Bewegungssensoren.' },
+  { name: 'Bewegungszugriff erlauben', text: 'Tippen Sie auf Kalibrierung starten und akzeptieren Sie die Aufforderung zur Bewegungs- oder Orientierungserlaubnis, falls Ihr Browser eine anzeigt.' },
+  { name: 'Neigung und Drehung testen', text: 'Kippen Sie das Handy nach vorne, rollen Sie es nach links und rechts, dann drehen Sie es flach auf einem Tisch. Achten Sie auf gleichmäßige Änderungen von Alpha, Beta, Gamma und Beschleunigung.' },
+  { name: 'Drift auf einer flachen Oberfläche prüfen', text: 'Lassen Sie das Handy mehrere Sekunden lang still liegen. Ein gesunder Sensor sollte sich stabilisieren, anstatt ständig zu wandern, Spitzen zu zeigen oder einzufrieren.' },
+];
+
+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<MobileSensorTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'Online-Gyroskop- und Beschleunigungssensor-Test für Handys', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Verwenden Sie diesen Handy-Sensor-Test, wenn sich die Bildschirmdrehung falsch anfühlt, Spiele oder AR-Apps driften, eine Wasserwaagen-App ungenau wirkt, die Navigation in die falsche Richtung zeigt oder das Handy nicht korrekt auf Neigung reagiert. Der Test zeigt live das Verhalten von Gyroskop, Beschleunigungssensor, Drehung und Wasserwaage, damit Sie ein Browser-Berechtigungsproblem von einem echten Sensor- oder Kalibrierungsproblem unterscheiden können.',
+    },
+    {
+      type: 'stats',
+      items: [
+        { label: 'Hauptsuchabsicht', value: 'Gyroskop online testen' },
+        { label: 'Prüft auch', value: 'Beschleunigungssensor-Drift' },
+        { label: 'Bestes Gerät', value: 'Handy oder Tablet' },
+      ],
+    },
+    { type: 'title', text: 'Was Ihnen die einzelnen Sensorwerte sagen', level: 3 },
+    {
+      type: 'table',
+      headers: ['Messwert', 'Nützlich für', 'Warnsignale'],
+      rows: [
+        ['Alpha', 'Prüfung der Drehung um die vertikale Achse, nützlich für kompassartige Bewegungen und Kursänderungen.', 'Ändert sich nicht beim flachen Drehen des Handys, springt in großen Schritten oder bleibt bei Null eingefroren.'],
+        ['Beta', 'Prüfung der Vorwärts-Rückwärts-Neigung für Bildschirmdrehung, Spiele, Kamera-Nivellierung und AR-Steuerung.', 'Bewegt sich in die falsche Richtung, bleibt bei einem Wert hängen oder driftet ständig, während das Handy still liegt.'],
+        ['Gamma', 'Prüfung der Links-Rechts-Rollbewegung für Querformat-Drehung, Rennspiele, Wasserwaagen-Apps und Stabilisatoren.', 'Eine Seite reagiert anders, die Werte sind verrauscht oder die Blase zentriert sich nie auf einem flachen Tisch.'],
+        ['Beschleunigung X/Y/Z', 'Prüfung der Beschleunigungssensor-Reaktion, Schüttelerkennung, Schwerkraftrichtung und Bewegungsstabilität.', 'Große Spitzen im Stillstand, keine Reaktion auf Bewegung oder instabile Messwerte nach Entfernen der Hülle.'],
+      ],
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Symptome, bei deren Diagnose dieser Test hilft',
+      html: '<p>Nutzen Sie die Live-Werte, um folgende Probleme zu untersuchen: Nicht funktionierende automatische Drehung, ein verzögert wirkendes Gyroskop, Beschleunigungssensor-Drift, Kompass-Kalibrierungswarnungen, wegrutschendes AR-Tracking, Kamera-Wasserwaagenfehler, Bewegungssteuerungen, die zu einer Seite ziehen, oder ein Handy, das Bewegung nur in nativen Apps, aber nicht im Browser meldet.</p>',
+    },
+    { type: 'title', text: 'Gyroskop vs. Beschleunigungssensor vs. Kompass', level: 3 },
+    {
+      type: 'comparative',
+      items: [
+        { title: 'Gyroskop', description: 'Misst die Drehgeschwindigkeit. Wichtig für AR, Spiele, Kamerastabilisierung, Bewegungssteuerung und gleichmäßige Orientierungsänderungen.' },
+        { title: 'Beschleunigungssensor', description: 'Misst Beschleunigung und Schwerkraftrichtung. Ermöglicht Neigung, Schüttelerkennung, Schrittzählung und das Verhalten der digitalen Wasserwaage.' },
+        { title: 'Kompass / Magnetometer', description: 'Hilft bei der Schätzung des Kurses, kann aber durch Magnete, Metallgegenstände, Autohalterungen, Hüllen, Lautsprecher, Laptops und nahe Elektronik gestört werden.' },
+      ],
+    },
+    { type: 'title', text: 'So testen Sie die Sensorkalibrierung richtig', level: 3 },
+    {
+      type: 'list',
+      items: [
+        'Entfernen Sie vor dem Test magnetische Hüllen, MagSafe-Geldbörsen, Metallhalterungen, Controller-Clips und Zubehör.',
+        'Legen Sie das Handy auf einen stabilen, flachen Tisch und warten Sie mehrere Sekunden, bevor Sie die Drift beurteilen.',
+        'Drehen Sie das Handy langsam durch jede Achse, anstatt es sofort zu schütteln.',
+        'Vergleichen Sie Safari oder Chrome mit einer nativen Sensor- oder Kompass-App, wenn der Browser keine Daten anzeigt.',
+        'Starten Sie das Gerät neu und wiederholen Sie den Test, wenn die Messwerte in mehreren Apps eingefroren sind.',
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Hinweis zu Berechtigungen bei iPhone und Android',
+      html: 'Auf iPhone und iPad kann Safari nach einer Berührung nach Bewegungs- und Orientierungserlaubnis fragen. Unter Android stellt Chrome Bewegungssensoren in der Regel direkter bereit, aber Datenschutzeinstellungen, Browser-Flags, Energiesparmodi und eingebettete Webviews können die Sensordaten immer noch blockieren oder reduzieren.',
+    },
+    {
+      type: 'table',
+      headers: ['Problem', 'Wahrscheinliche Ursache', 'Nächster Schritt'],
+      rows: [
+        ['Keine Werte ändern sich', 'Erlaubnis verweigert, nicht unterstützter Browser, Desktop-Gerät oder eingeschränkte Webview.', 'Auf dem Handy selbst öffnen, Safari oder Chrome verwenden, Bewegungszugriff erlauben und die Seite neu laden.'],
+        ['Blase driftet auf einem Tisch', 'Kalibrierungsproblem, unebene Oberfläche, Hüllen-Interferenz oder Beschleunigungssensor-Rauschen.', 'Hülle entfernen, eine bekanntermaßen ebene Fläche verwenden, neu starten und mit einer nativen Wasserwaagen-App vergleichen.'],
+        ['Kompassrichtung ist falsch', 'Magnetische Interferenz oder System-Kompasskalibrierung.', 'Von Metall/Elektronik entfernen und den Kompass-Kalibrierungsablauf des Betriebssystems verwenden.'],
+        ['Werte springen oder zeigen Spitzen', 'Sensorrauschen, beschädigte Hardware, aggressives Browser-Drosseling oder plötzliche physische Bewegung.', 'Im Stillstand testen, rechenintensive Apps schließen und mit einem anderen Browser oder einer nativen App vergleichen.'],
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Wofür dieser Test gut ist',
+      items: [
+        'Testen eines Handy-Gyroskops online, ohne eine App zu installieren.',
+        'Überprüfen der Beschleunigungssensor-Drift mit einer Live-Wasserwaage.',
+        'Herausfinden, ob Bewegungssteuerungen aufgrund von Hardware, Kalibrierung, Berechtigungen oder Browser-Unterstützung versagen.',
+        'Vorbereiten eines Handys für AR, Spiele, Kamera-Nivellierung, Navigation oder Fehlerbehebung bei der Bildschirmdrehung.',
+      ],
+    },
+  ],
+  ui: {
+    startButton: 'Kalibrierung starten',
+    permissionHint: 'Einmal tippen, um Bewegungssensoren freizuschalten',
+    privacyBadge: 'Lokale Sensordaten',
+    privacyCopy: 'Orientierungs- und Bewegungswerte bleiben innerhalb dieser Browser-Sitzung.',
+    orientationPanel: 'Orientierung',
+    motionPanel: 'Bewegung',
+    bubblePanel: 'Digitale Wasserwaage',
+    statusReady: 'Bereit für Sensorerlaubnis',
+    statusWaiting: 'Warte auf Browser-Erlaubnis',
+    statusDenied: 'Sensorzugriff wurde verweigert oder ist nicht verfügbar',
+    statusUnsupported: 'Bewegungssensoren werden von diesem Browser nicht bereitgestellt',
+    statusActive: 'Live-Sensorstrom aktiv',
+    steadyLabel: 'Ruhig',
+    movingLabel: 'In Bewegung',
+    shakingLabel: 'Schüttelnd',
+    alphaLabel: 'Alpha',
+    betaLabel: 'Beta',
+    gammaLabel: 'Gamma',
+    accelXLabel: 'X',
+    accelYLabel: 'Y',
+    accelZLabel: 'Z',
+    rotationAlphaLabel: 'Rot A',
+    rotationBetaLabel: 'Rot B',
+    rotationGammaLabel: 'Rot G',
+    levelOffsetLabel: 'Wasserwaagen-Abweichung',
+    motionMagnitudeLabel: 'Bewegungsstärke',
+    cubeLabel: '3D-Geräte-Orientierungswürfel',
+    bubbleLabel: 'Wasserwaagen-Anzeige',
+    calibrationLabel: 'Live-Grad',
+  },
+};