@jjlmoya/utils-astronomy 1.28.0 → 1.34.1

package/src/tool/meteorShowerObservingPlanner/controller.ts

@@ -0,0 +1,178 @@
+import type { ObservingPlannerInput, MeteorShowerObservingPlannerUI, EvaluationResult } from './ui';
+import { evaluateObservingSession } from './logic';
+import { renderSkyDomeSvg, renderHourlyBars } from './dom-views';
+import { getQualityBadgeClass, formatZHRDisplay } from './evaluator';
+import { saveInput } from './storage';
+
+interface MenuOptParams {
+  opt: HTMLButtonElement;
+  label: HTMLElement;
+  opts: NodeListOf<HTMLButtonElement>;
+  trigger: HTMLButtonElement;
+  menu: HTMLElement;
+  onSelect: (val: number) => void;
+}
+
+export class MeteorShowerPlannerController {
+  private input: ObservingPlannerInput;
+  private ui: MeteorShowerObservingPlannerUI;
+  private rootEl: HTMLElement;
+
+  constructor(rootEl: HTMLElement, initialInput: ObservingPlannerInput, ui: MeteorShowerObservingPlannerUI) {
+    this.rootEl = rootEl;
+    this.input = { ...initialInput };
+    this.ui = ui;
+    this.init();
+  }
+
+  private init(): void {
+    this.bindEvents();
+    this.update();
+  }
+
+  private bindMenuOpt(params: MenuOptParams): void {
+    params.opt.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const val = parseInt(params.opt.getAttribute('data-val') || '0', 10);
+      params.label.textContent = `${String(val).padStart(2, '0')}:00`;
+      params.opts.forEach((o) => o.classList.remove('active'));
+      params.opt.classList.add('active');
+      params.trigger.setAttribute('aria-expanded', 'false');
+      params.menu.setAttribute('hidden', '');
+      params.onSelect(val);
+    });
+  }
+
+  private bindCustomSelect(triggerId: string, menuId: string, labelId: string, onSelect: (val: number) => void): void {
+    const trigger = this.rootEl.querySelector<HTMLButtonElement>(`#${triggerId}`);
+    const menu = this.rootEl.querySelector<HTMLElement>(`#${menuId}`);
+    const label = this.rootEl.querySelector<HTMLElement>(`#${labelId}`);
+    if (!trigger || !menu || !label) return;
+
+    trigger.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const isExpanded = trigger.getAttribute('aria-expanded') === 'true';
+      this.closeAllCustomSelects();
+      if (!isExpanded) {
+        trigger.setAttribute('aria-expanded', 'true');
+        menu.removeAttribute('hidden');
+      }
+    });
+
+    const opts = menu.querySelectorAll<HTMLButtonElement>('.custom-select-opt');
+    opts.forEach((opt) => this.bindMenuOpt({ opt, label, opts, trigger, menu, onSelect }));
+  }
+
+  private closeAllCustomSelects(): void {
+    const triggers = this.rootEl.querySelectorAll<HTMLButtonElement>('.custom-select-trigger');
+    const menus = this.rootEl.querySelectorAll<HTMLElement>('.custom-select-menu');
+    triggers.forEach((t) => t.setAttribute('aria-expanded', 'false'));
+    menus.forEach((m) => m.setAttribute('hidden', ''));
+  }
+
+  private bindPresets(): void {
+    const presetBtns = this.rootEl.querySelectorAll<HTMLButtonElement>('.preset-chip-btn');
+    presetBtns.forEach((btn) => {
+      btn.addEventListener('click', () => {
+        const id = btn.getAttribute('data-shower-id');
+        if (id) {
+          this.input.showerId = id;
+          presetBtns.forEach((b) => b.classList.remove('active'));
+          btn.classList.add('active');
+          const customGroup = this.rootEl.querySelector<HTMLElement>('.custom-zhr-group');
+          if (customGroup) customGroup.style.display = id === 'custom' ? 'block' : 'none';
+          this.update();
+        }
+      });
+    });
+  }
+
+  private bindSliders(): void {
+    const lat = this.rootEl.querySelector<HTMLInputElement>('#planner-latitude-input');
+    if (lat) {
+      lat.addEventListener('input', (e) => {
+        this.input.latitude = parseFloat((e.target as HTMLInputElement).value);
+        const disp = this.rootEl.querySelector('#planner-latitude-val');
+        if (disp) disp.textContent = `${this.input.latitude > 0 ? '+' : ''}${this.input.latitude}°`;
+        this.update();
+      });
+    }
+
+    const bortle = this.rootEl.querySelector<HTMLInputElement>('#planner-bortle-input');
+    if (bortle) {
+      bortle.addEventListener('input', (e) => {
+        this.input.bortleClass = parseInt((e.target as HTMLInputElement).value, 10);
+        const disp = this.rootEl.querySelector('#planner-bortle-val');
+        if (disp) disp.textContent = `${this.ui.classLabel || 'Class'} ${this.input.bortleClass}`;
+        this.update();
+      });
+    }
+
+    const moon = this.rootEl.querySelector<HTMLInputElement>('#planner-moon-input');
+    if (moon) {
+      moon.addEventListener('input', (e) => {
+        this.input.moonPhase = parseFloat((e.target as HTMLInputElement).value);
+        const disp = this.rootEl.querySelector('#planner-moon-val');
+        if (disp) disp.textContent = `${Math.round(this.input.moonPhase * 100)}%`;
+        this.update();
+      });
+    }
+  }
+
+  private bindEvents(): void {
+    document.addEventListener('click', () => this.closeAllCustomSelects());
+    this.bindPresets();
+    this.bindSliders();
+
+    const customZhr = this.rootEl.querySelector<HTMLInputElement>('#planner-custom-zhr-input');
+    if (customZhr) {
+      customZhr.addEventListener('input', (e) => {
+        this.input.customZhr = Math.max(1, parseInt((e.target as HTMLInputElement).value, 10) || 50);
+        this.update();
+      });
+    }
+
+    this.bindCustomSelect('planner-start-hour-btn', 'planner-start-hour-menu', 'planner-start-hour-label', (val) => {
+      this.input.sessionStartHour = val;
+      this.update();
+    });
+
+    this.bindCustomSelect('planner-end-hour-btn', 'planner-end-hour-menu', 'planner-end-hour-label', (val) => {
+      this.input.sessionEndHour = val;
+      this.update();
+    });
+  }
+
+  private updateMetrics(evaluation: EvaluationResult): void {
+    const bestWindowEl = this.rootEl.querySelector('.res-best-window');
+    if (bestWindowEl) bestWindowEl.textContent = `${evaluation.bestWindowStart} - ${evaluation.bestWindowEnd}`;
+
+    const maxRateEl = this.rootEl.querySelector('.res-max-rate');
+    if (maxRateEl) maxRateEl.textContent = formatZHRDisplay(evaluation.maxEffectiveRate, this.ui);
+
+    const scoreValEl = this.rootEl.querySelector('.res-score-val');
+    if (scoreValEl) {
+      scoreValEl.textContent = `${evaluation.overallScore}/100`;
+      scoreValEl.className = `res-score-val ${getQualityBadgeClass(evaluation.overallScore)}`;
+    }
+  }
+
+  public update(): void {
+    saveInput(this.input);
+    const evaluation = evaluateObservingSession(this.input, this.ui);
+    this.updateMetrics(evaluation);
+
+    const badgesContainer = this.rootEl.querySelector('.res-badges-list');
+    if (badgesContainer) {
+      badgesContainer.innerHTML = evaluation.badges
+        .map((b) => `<span class="badge badge-${b.type}">${b.label}</span>`)
+        .join('');
+    }
+
+    const domeContainer = this.rootEl.querySelector('.sky-dome-container');
+    if (domeContainer) domeContainer.innerHTML = renderSkyDomeSvg(this.input, evaluation, this.ui);
+
+    const barsContainer = this.rootEl.querySelector('.hourly-bars-track');
+    if (barsContainer) barsContainer.innerHTML = renderHourlyBars(evaluation.hourlyBreakdown);
+  }
+}

package/src/tool/meteorShowerObservingPlanner/dom-views.ts

@@ -0,0 +1,187 @@
+import type { EvaluationResult, HourlyCalculation, ObservingPlannerInput, MeteorShowerObservingPlannerUI } from './ui';
+import { getShowerById, calculateRadiantElevation } from './logic';
+
+interface MoonGraphicParams {
+  moonPhase: number;
+  x: number;
+  y: number;
+  moonTxt: string;
+}
+
+function renderSkyDomeBackground(moonGlowOpacity: string): string {
+  return `
+    <defs>
+      <radialGradient id="skyBgGrad" cx="50%" cy="100%" r="90%">
+        <stop offset="0%" stop-color="#1e293b"/>
+        <stop offset="100%" stop-color="#090d16"/>
+      </radialGradient>
+      <radialGradient id="moonGlowGrad" cx="50%" cy="50%" r="50%">
+        <stop offset="0%" stop-color="#fff8e7" stop-opacity="${moonGlowOpacity}"/>
+        <stop offset="100%" stop-color="#fff8e7" stop-opacity="0"/>
+      </radialGradient>
+    </defs>
+    <rect width="400" height="230" rx="16" fill="url(#skyBgGrad)"/>
+    <circle cx="50" cy="35" r="1" fill="#fff" opacity="0.8"/>
+    <circle cx="130" cy="55" r="1.5" fill="#fff" opacity="0.9"/>
+    <circle cx="270" cy="25" r="1.2" fill="#fff" opacity="0.7"/>
+    <circle cx="350" cy="65" r="1" fill="#fff" opacity="0.8"/>
+    <circle cx="190" cy="40" r="1" fill="#fff" opacity="0.6"/>
+  `;
+}
+
+function renderSkyDomeGrid(): string {
+  return `
+    <line x1="30" y1="130" x2="370" y2="130" stroke="rgba(255,255,255,0.08)" stroke-dasharray="3,3"/>
+    <text x="375" y="133" fill="#64748b" font-size="9">30°</text>
+    <line x1="30" y1="80" x2="370" y2="80" stroke="rgba(255,255,255,0.08)" stroke-dasharray="3,3"/>
+    <text x="375" y="83" fill="#64748b" font-size="9">60°</text>
+    <line x1="20" y1="180" x2="380" y2="180" stroke="rgba(255,255,255,0.25)" stroke-width="1.5"/>
+    <text x="30" y="200" fill="#cbd5e1" font-size="11" font-weight="600">E</text>
+    <text x="200" y="200" text-anchor="middle" fill="#cbd5e1" font-size="11" font-weight="600">S</text>
+    <text x="370" y="200" text-anchor="end" fill="#cbd5e1" font-size="11" font-weight="600">W</text>
+  `;
+}
+
+function renderTelemetryCard(title: string, constName: string, statusTxt: string, badgeColor: string): string {
+  return `
+    <g transform="translate(14, 20)">
+      <rect width="145" height="34" rx="6" fill="rgba(15, 23, 42, 0.75)" stroke="rgba(255,255,255,0.12)" stroke-width="1"/>
+      <text x="8" y="14" fill="#94a3b8" font-size="9" font-weight="600">${title}</text>
+      <text x="8" y="27" fill="${badgeColor}" font-size="11" font-weight="700">${constName} (${statusTxt})</text>
+    </g>
+  `;
+}
+
+function renderMoonGraphic(params: MoonGraphicParams): string {
+  if (params.moonPhase <= 0.05) return '';
+  const percent = Math.round(params.moonPhase * 100);
+  const pathCurv = (10 * (1 - params.moonPhase * 2)).toFixed(1);
+  return `
+    <circle cx="${params.x}" cy="${params.y}" r="28" fill="url(#moonGlowGrad)"/>
+    <circle cx="${params.x}" cy="${params.y}" r="10" fill="#e2e8f0"/>
+    <path d="M ${params.x} ${params.y - 10} A 10 10 0 0 1 ${params.x} ${params.y + 10} A ${pathCurv} 10 0 0 1 ${params.x} ${params.y - 10}" fill="#090d16"/>
+    <text x="${params.x}" y="${params.y + 20}" text-anchor="middle" fill="#94a3b8" font-size="9">${percent}% ${params.moonTxt}</text>
+  `;
+}
+
+function renderMeteorStreaks(isAbove: boolean, zhr: number, rx: number, ry: number): string {
+  if (!isAbove || zhr <= 2) return '';
+  const streakCount = Math.min(7, Math.max(2, Math.floor(zhr / 8)));
+  const angles = [35, 70, 120, 145, 210, 250, 310];
+  const lengths = [35, 55, 40, 60, 45, 50, 65];
+
+  return angles
+    .slice(0, streakCount)
+    .map((ang, idx) => {
+      const rad = (ang * Math.PI) / 180;
+      const len = lengths[idx % lengths.length];
+      const x2 = Math.round(rx + Math.cos(rad) * len);
+      const y2 = Math.round(ry + Math.sin(rad) * len);
+      const opacity = (0.5 + (idx % 3) * 0.2).toFixed(2);
+      return `<line x1="${rx}" y1="${ry}" x2="${x2}" y2="${y2}" stroke="#a5b4fc" stroke-width="1.8" stroke-dasharray="80" stroke-linecap="round" opacity="${opacity}"/>`;
+    })
+    .join('');
+}
+
+function renderRadiantMarker(isAbove: boolean, rx: number, ry: number, belowTxt: string): string {
+  if (isAbove) {
+    return `
+      <path d="M 20 180 Q ${rx} ${ry - 15} 380 180" fill="none" stroke="rgba(129, 140, 248, 0.35)" stroke-dasharray="4,4" stroke-width="1.5"/>
+      <g transform="translate(${rx}, ${ry})">
+        <circle r="15" fill="none" stroke="#6366f1" stroke-width="2" opacity="0.9"/>
+        <circle r="5" fill="#818cf8"/>
+        <line x1="-20" y1="0" x2="20" y2="0" stroke="#818cf8" stroke-width="1.5"/>
+        <line x1="0" y1="-20" x2="0" y2="20" stroke="#818cf8" stroke-width="1.5"/>
+      </g>
+    `;
+  }
+  return `
+    <g transform="translate(${rx}, 195)">
+      <circle r="10" fill="none" stroke="#f43f5e" stroke-width="1.5" stroke-dasharray="2,2"/>
+      <text x="0" y="16" text-anchor="middle" fill="#f43f5e" font-size="9" font-weight="600">${belowTxt}</text>
+    </g>
+  `;
+}
+
+interface DomeCoords {
+  peakHour: number;
+  elev: number;
+  isAbove: boolean;
+  radiantX: number;
+  radiantY: number;
+  moonX: number;
+  moonY: number;
+}
+
+function calculateDomeCoords(input: ObservingPlannerInput, evaluation: EvaluationResult): DomeCoords {
+  const peakItem = evaluation.hourlyBreakdown.find((h) => h.isPeakHour) || evaluation.hourlyBreakdown[0];
+  const peakHour = peakItem ? peakItem.hour : 2;
+
+  const elev = Math.round(calculateRadiantElevation(peakHour, input.latitude, input.showerId));
+  const isAbove = elev > 0;
+  const clampedElev = Math.max(-15, Math.min(88, elev));
+  const radiantY = Math.round(180 - (Math.max(0, clampedElev) / 90) * 135);
+  const radiantX = Math.round(200 + (((135 + ((peakHour % 12) / 12) * 90) - 180) / 90) * 140);
+
+  const moonX = Math.round(80 + ((peakHour % 10) / 10) * 240);
+  const moonY = Math.round(70 + Math.sin(peakHour * 0.5) * 30);
+
+  return { peakHour, elev, isAbove, radiantX, radiantY, moonX, moonY };
+}
+
+function getConstellationName(constKey: string, ui?: MeteorShowerObservingPlannerUI): string {
+  if (!ui || !ui.constellations) return constKey;
+  return ui.constellations[constKey] || constKey;
+}
+
+function getStatusText(isAbove: boolean, elev: number, ui?: MeteorShowerObservingPlannerUI): string {
+  const alt = ui && ui.altLabel ? ui.altLabel : 'Alt';
+  const below = ui && ui.belowHorizonLabel ? ui.belowHorizonLabel : 'Below Horizon';
+  return isAbove ? `+${elev}° ${alt}` : below;
+}
+
+export function renderSkyDomeSvg(input: ObservingPlannerInput, evaluation: EvaluationResult, ui?: MeteorShowerObservingPlannerUI): string {
+  const shower = getShowerById(input.showerId);
+  const coords = calculateDomeCoords(input, evaluation);
+  const peakItem = evaluation.hourlyBreakdown.find((h) => h.isPeakHour) || evaluation.hourlyBreakdown[0];
+
+  const moonOpacity = (input.moonPhase * 0.5).toFixed(2);
+  const constName = getConstellationName(shower.radiantConstellation, ui);
+  const statusTxt = getStatusText(coords.isAbove, coords.elev, ui);
+  const moonLabelTxt = ui && ui.moonLabel ? ui.moonLabel : 'Moon';
+  const belowHorizonTxt = ui && ui.belowHorizonLabel ? ui.belowHorizonLabel : 'Below Horizon';
+  const telemetryTitle = ui && ui.radiantTelemetryLabel ? ui.radiantTelemetryLabel : 'RADIANT TELEMETRY';
+
+  const moonParams: MoonGraphicParams = { moonPhase: input.moonPhase, x: coords.moonX, y: coords.moonY, moonTxt: moonLabelTxt };
+
+  return `
+    <svg class="sky-dome-svg" viewBox="0 0 400 230" role="img" aria-label="Celestial Sky Dome">
+      ${renderSkyDomeBackground(moonOpacity)}
+      ${renderSkyDomeGrid()}
+      ${renderTelemetryCard(telemetryTitle, constName, statusTxt, coords.isAbove ? '#10b981' : '#f43f5e')}
+      ${renderMoonGraphic(moonParams)}
+      ${renderMeteorStreaks(coords.isAbove, peakItem ? peakItem.effectiveZhr : 0, coords.radiantX, coords.radiantY)}
+      ${renderRadiantMarker(coords.isAbove, coords.radiantX, coords.radiantY, belowHorizonTxt)}
+    </svg>
+  `;
+}
+
+export function renderHourlyBars(breakdown: HourlyCalculation[]): string {
+  if (breakdown.length === 0) return '';
+  const maxZhr = Math.max(...breakdown.map((b) => b.effectiveZhr), 1);
+
+  return breakdown
+    .map((item) => {
+      const heightPercent = Math.max(8, Math.round((item.effectiveZhr / maxZhr) * 100));
+      return `
+        <div class="hourly-bar-col ${item.isPeakHour ? 'is-peak' : ''}">
+          <span class="bar-val">${item.effectiveZhr.toFixed(0)}</span>
+          <div class="bar-track">
+            <div class="bar-fill" style="height: ${heightPercent}%"></div>
+          </div>
+          <span class="bar-label">${item.formattedTime}</span>
+        </div>
+      `;
+    })
+    .join('');
+}

package/src/tool/meteorShowerObservingPlanner/entry.ts

@@ -0,0 +1,29 @@
+import type { AstronomyToolEntry } from '../../types';
+import type { MeteorShowerObservingPlannerUI, MeteorShowerObservingPlannerLocaleContent } from './ui';
+
+export type { MeteorShowerObservingPlannerUI, MeteorShowerObservingPlannerLocaleContent };
+
+export const meteorShowerObservingPlanner: AstronomyToolEntry<MeteorShowerObservingPlannerUI> = {
+  id: 'meteor-shower-observing-planner',
+  icons: {
+    bg: 'mdi:weather-night',
+    fg: 'mdi:star-shooting',
+  },
+  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/meteorShowerObservingPlanner/evaluator.ts

@@ -0,0 +1,20 @@
+import type { EvaluationResult, MeteorShowerObservingPlannerUI } from './ui';
+
+export function getQualityBadgeClass(score: number): string {
+  if (score >= 70) {
+    return 'badge-excellent';
+  }
+  if (score >= 40) {
+    return 'badge-moderate';
+  }
+  return 'badge-poor';
+}
+
+export function formatZHRDisplay(val: number, ui?: MeteorShowerObservingPlannerUI): string {
+  const unit = ui?.hrUnit || '/ hr';
+  return `${val.toFixed(1)} ${unit}`;
+}
+
+export function calculateSummaryBadges(evaluation: EvaluationResult): Array<{ label: string; type: string }> {
+  return evaluation.badges;
+}

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

@@ -0,0 +1,219 @@
+import type { MeteorShowerObservingPlannerLocaleContent } from '../ui';
+import { METEOR_PLANNER_BIBLIOGRAPHY } from '../bibliography';
+
+const slug = 'planer-fuer-meteorstrom-beobachtung';
+
+export const content: MeteorShowerObservingPlannerLocaleContent = {
+  slug,
+  title: 'Meteorstrom Beobachtungsfenster Planer',
+  description: 'Planen Sie optimale Beobachtungszeiten für Sternschnuppen mit Berechnung der effektiven stündlichen ZHR Rate und Mondlichtdämpfung.',
+  ui: {
+    title: 'Meteorstrom Beobachtungsplaner',
+    subtitle: 'Berechnen Sie optimale Fenster und vorhergesagte Raten pro Stunde',
+    presetLabel: 'Hauptmeteorstrom auswählen',
+    customZhrLabel: 'Benutzerdefinierte ZHR Rate',
+    latitudeLabel: 'Breitengrad des Beobachters',
+    bortleLabel: 'Bortle Skala für Himmelsdunkelheit',
+    moonPhaseLabel: 'Mondphase und Beleuchtung',
+    sessionHoursLabel: 'Geplante Beobachtungsstunden',
+    toLabel: 'bis',
+    classLabel: 'Klasse',
+    radiantTelemetryLabel: 'RADIANTE-TELEMETRIE',
+    belowHorizonLabel: 'Unter dem Horizont',
+    altLabel: 'Höhe',
+    moonLabel: 'Mond',
+    hrUnit: '/ Std',
+    presets: {
+      perseids: 'Perseiden (12 Aug)',
+      geminids: 'Geminiden (14 Dez)',
+      quadrantids: 'Quadranten (4 Jan)',
+      lyrids: 'Lyriden (22 Apr)',
+      orionids: 'Orioniden (21 Okt)',
+      'eta-aquariids': 'Eta Aquariiden (6 Mai)',
+      leonids: 'Leoniden (17 Nov)',
+      custom: 'Benutzerdefinierter Strom',
+    },
+    constellations: {
+      Perseus: 'Perseus',
+      Gemini: 'Zwillinge',
+      Bootes: 'Bärenhüter',
+      Lyra: 'Leier',
+      Orion: 'Orion',
+      Aquarius: 'Wassermann',
+      Leo: 'Löwe',
+      Zenith: 'Zenit',
+    },
+    badgeLabels: {
+      darkSky: 'Exzellenter Dunkler Himmel',
+      lightPollution: 'Hohe Lichtverschmutzung',
+      favorableMoon: 'Günstiger Mond',
+      moonWashout: 'Risiko durch Mondschein',
+      primeWindow: 'Hauptaktivitätsfenster',
+    },
+    bortleDescriptions: {
+      2: 'Exzellenter dunkler Himmel',
+      5: 'Vorstädtischer Himmel',
+      8: 'Städtische Lichtverschmutzung',
+    },
+    moonPhaseNames: {
+      new: 'Minimaler Mondschein',
+      quarter: 'Moderate Mondstörung',
+      full: 'Starke Mondüberstrahlung',
+    },
+    resultsTitle: 'Analyse der Beobachtungssitzung',
+    bestWindowLabel: 'Bestes Beobachtungsfenster',
+    maxRateLabel: 'Maximale sichtbare Rate',
+    skyQualityLabel: 'Himmelsqualitätsindex',
+    hourlyChartTitle: 'Stündliche Vorhersage und Radiantenhöhe',
+    checklistTitle: 'Vorbereitung auf die Beobachtung',
+    checklistItems: [
+      'Gönnen Sie Ihren Augen mindestens 20 Minuten Dunkeladaption vor dem Zählen',
+      'Verwenden Sie Rotlichtlampen um die Nachtsicht zu bewahren',
+      'Nutzen Sie einen bequemen Liegestuhl mit Blick 45 Grad über dem Horizont',
+      'Vermeiden Sie den Blick auf helle Smartphone Displayanzeigen',
+    ],
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Bedeutung der Zenitrate ZHR und der sichtbaren Meteore',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Zenitrate ZHR gibt die theoretische Höchstzahl an Sternschnuppen an die ein Beobachter unter idealem dunklem Himmel mit dem Radianten direkt im Zenit sehen würde. In der Praxis liegt die tatsächlich sichtbare Zahl aufgrund von Lichtverschmutzung und Radiantenhöhe deutlich niedriger. Atmosphärische Extinktion dämpft das Licht schwacher Meteorspuren zusätzlich ab.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Planung optimaler Beobachtungsfenster erfordert die Berücksichtigung geometrischer Umweltfaktoren. Steht der Radiant nah am Horizont verlaufen viele Meteorbahnen außerhalb des Blickfeldes. Beobachter in städtischen Gebieten müssen mit weiteren Verlusten durch Straßenlaternen und Gebäudebelichtung rechnen.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Der Höheneinfluss des Radianten reduziert die Rate proportional zum Sinus der Höhe',
+        'Lichtverschmutzung nach Bortle dämpft schwache Sternschnuppenspuren',
+        'Mondlicht erzeugt eine Aufhellung des Hintergrundhimmels',
+        'Das eigene Sehfeld begrenzt den sichtbaren Bereich',
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Empfehlung für Dunklen Himmel',
+      html: 'Beobachtungen von Standorten der Bortle Klasse 2 oder 3 steigern die Zahl sichtbarer schwacher Meteore erheblich im Vergleich zu Balkonen in Großstädten.',
+    },
+    {
+      type: 'title',
+      text: 'Einfluss von Mondphase und Lichtverschmutzung',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Mondlicht ist der stärkste natürliche Störfaktor während eines Meteorstroms. Ein heller Halbmond oder Vollmond überstrahlt schwache Spuren und verringert die sichtbare Rate um über 70 Prozent selbst bei feinstem Landhimmel. Eine dunkle Neumondnacht ist daher die allerbeste Voraussetzung für astronomische Beobachtungen.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Beobachtungsstunden nach Monduntergang oder vor Mondaufgang bieten den besten Kontrast zum Nachthimmel. Beobachtungen um die astronomische Mitternacht versprechen die höchste Dunkelheit und beste Chancen auf helle Feuerbälle.',
+    },
+    {
+      type: 'title',
+      text: 'Tipps für eine Erfolgreiche Beobachtungsnacht',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Erfolgreiche Sternschnuppenbeobachtung erfordert Geduld und gute Kleidung. Da Meteore überraschend auftreten bietet das freie Auge ein wesentlich breiteres Sehfeld als Teleskope oder Ferngläser.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Tragen Sie warme Kleidung in Schichten auch in Sommernächten',
+        'Bringen Sie einen Schlafsack oder eine Decke für Liegestühle mit',
+        'Halten Sie warme Getränke bereit um die Körperwärme zu halten',
+        'Notieren Sie Uhrzeit und Richtung sehr heller Feuerbälle',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Technische Berechungsmethodik',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieser Planer berechnet die effektive Rate durch Verknüpfung der Spitzen ZHR mit geometrischen Höhenfaktoren Himmelsdunkelheit und Mondphasenkorrekturen für realistische Erwartungen am Beobachtungsort. Dies hilft Amateurastronomen bei der Planung.',
+    },
+  ],
+  faq: [
+    {
+      question: 'Was bedeutet Zenitrate ZHR?',
+      answer: 'Die ZHR ist die theoretische Maximalzahl an Meteoren pro Stunde unter komplett dunklem Himmel mit dem Radianten im Zenit.',
+    },
+    {
+      question: 'Warum sehe ich weniger Sternschnuppen als angegeben?',
+      answer: 'Angegebene ZHR Werte setzen perfekten dunklen Himmel voraus. Lichtverschmutzung und Mondschein reduzieren die sichtbare Zahl.',
+    },
+    {
+      question: 'Benötige ich ein Teleskop für Sternschnuppen?',
+      answer: 'Nein Teleskope verengen das Blickfeld zu stark. Die Beobachtung mit bloßem Auge ist am besten geeignet.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Meteorstrom auswählen',
+      text: 'Wählen Sie einen vorgegebenen Meteorstrom wie die Perseiden oder geben Sie eigene Werte ein.',
+    },
+    {
+      name: 'Breitengrad einstellen',
+      text: 'Passen Sie den Regler an Ihren aktuellen Standort an.',
+    },
+    {
+      name: 'Dunkelheit und Mondphase konfigurieren',
+      text: 'Stellen Sie die lokale Bortle Klasse und die aktuelle Mondbeleuchtung ein.',
+    },
+    {
+      name: 'Vorhersage prüfen',
+      text: 'Analysieren Sie das Diagramm für Ihr optimales Fenster.',
+    },
+  ],
+  bibliography: METEOR_PLANNER_BIBLIOGRAPHY,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Meteorstrom Beobachtungsfenster Planer',
+      operatingSystem: 'Any',
+      applicationCategory: 'EducationalApplication',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Was bedeutet Zenitrate ZHR?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Die ZHR ist die theoretische Maximalzahl an Meteoren pro Stunde unter komplett dunklem Himmel mit dem Radianten im Zenit.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'So nutzen Sie den Meteorstrom Beobachtungsplaner',
+      description: 'Anleitung zur Ermittlung des besten Beobachtungsfensters für Sternschnuppen.',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Meteorstrom auswählen',
+          text: 'Wählen Sie einen vorgegebenen Meteorstrom wie die Perseiden oder geben Sie eigene Werte ein.',
+        },
+      ],
+    },
+  ],
+};