@jjlmoya/utils-hardware 1.20.0 → 1.22.0

package/src/tool/upsRuntimeCalculator/component.astro

@@ -0,0 +1,384 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale } from '../../types';
+import type { UpsRuntimeCalculatorUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as UpsRuntimeCalculatorUI;
+---
+
+<div
+  class="ups-root"
+  data-config={JSON.stringify({
+    presetDesktop: t.presetDesktop,
+    presetMonitor: t.presetMonitor,
+    presetRouter: t.presetRouter,
+    presetNas: t.presetNas,
+    deviceName: t.deviceName,
+    watts: t.watts,
+    remove: t.remove,
+    bandLight: t.bandLight,
+    bandBalanced: t.bandBalanced,
+    bandHeavy: t.bandHeavy,
+    summaryPrefix: t.summaryPrefix,
+    minutes: t.minutes,
+    hours: t.hours,
+    wattsUnit: t.wattsUnit,
+    percentUnit: t.percentUnit,
+    assumptionsLabel: t.assumptionsLabel,
+  })}
+>
+  <section class="ups-panel">
+    <div class="ups-console ups-load">
+      <div class="ups-strip">
+        <span>{t.loadTitle}</span>
+        <button class="ups-add" type="button" data-add-device>{t.addDevice}</button>
+      </div>
+      <div class="ups-devices" data-devices></div>
+    </div>
+
+    <div class="ups-machine" aria-hidden="true">
+      <div class="ups-shell">
+        <div class="ups-port-row">
+          <i></i><i></i><i></i><i></i>
+        </div>
+        <div class="ups-screen">
+          <span data-runtime-big>0</span>
+          <small data-runtime-unit>{t.minutes}</small>
+        </div>
+        <div class="ups-core">
+          <b></b><b></b><b></b><b></b>
+        </div>
+      </div>
+      <div class="ups-energy-rail">
+        <span data-load-bar></span>
+      </div>
+    </div>
+
+    <div class="ups-console ups-controls" aria-label={t.assumptionsLabel}>
+      <label class="ups-capacity">
+        <span>{t.batteryWh}</span>
+        <span class="ups-number-field ups-number-field-large">
+          <input data-battery type="number" min="50" max="3000" step="10" value="432" />
+          <em>{t.whUnit}</em>
+        </span>
+      </label>
+      <label>
+        <span>{t.efficiency}</span>
+        <input data-efficiency type="range" min="70" max="95" value="86" />
+        <strong data-efficiency-label>86%</strong>
+      </label>
+      <label>
+        <span>{t.powerFactor}</span>
+        <input data-power-factor type="range" min="50" max="100" value="70" />
+        <strong data-power-factor-label>0.70</strong>
+      </label>
+      <label>
+        <span>{t.reserve}</span>
+        <input data-reserve type="range" min="0" max="50" value="20" />
+        <strong data-reserve-label>20%</strong>
+      </label>
+    </div>
+
+    <div class="ups-dashboard">
+      <div class="ups-metrics">
+        <article>
+          <span>{t.totalLoad}</span>
+          <strong><output data-total-load>0</output> {t.wattsUnit}</strong>
+          <i data-load-meter></i>
+        </article>
+        <article>
+          <span>{t.runtime}</span>
+          <strong><output data-runtime>0</output></strong>
+          <i data-runtime-meter></i>
+        </article>
+        <article>
+          <span>{t.recommendedUps}</span>
+          <strong><output data-recommended>0</output> {t.vaUnit}</strong>
+          <i data-va-meter></i>
+        </article>
+        <article>
+          <span>{t.usableEnergy}</span>
+          <strong><output data-usable-energy>0</output> {t.whUnit}</strong>
+          <i data-energy-meter></i>
+        </article>
+      </div>
+      <p class="ups-summary" data-summary></p>
+    </div>
+  </section>
+  <template data-trash-icon>
+    <Icon name="mdi:trash-can-outline" class="ups-trash-icon" />
+  </template>
+</div>
+
+<link rel="stylesheet" href="./ups-runtime-calculator.css" />
+
+<script>
+  interface Device {
+    name: string;
+    watts: number;
+  }
+  interface Config {
+    presetDesktop: string;
+    presetMonitor: string;
+    presetRouter: string;
+    presetNas: string;
+    deviceName: string;
+    watts: string;
+    remove: string;
+    bandLight: string;
+    bandBalanced: string;
+    bandHeavy: string;
+    summaryPrefix: string;
+    minutes: string;
+    hours: string;
+    wattsUnit: string;
+    percentUnit: string;
+    assumptionsLabel: string;
+  }
+  interface PersistedState {
+    devices?: Device[];
+    batteryWh?: string;
+    efficiency?: string;
+    powerFactor?: string;
+    reserve?: string;
+  }
+  type RuntimeStats = { totalWatts: number; usableWh: number; runtimeMinutes: number; recommendedWatts: number; recommendedVa: number };
+  const root = document.querySelector<HTMLElement>('.ups-root');
+  const storageKey = 'ups-runtime-calculator-state';
+  const config = JSON.parse(root?.dataset.config ?? '{}') as Config;
+  const defaultDevices: Device[] = [
+    { name: config.presetDesktop, watts: 260 },
+    { name: config.presetMonitor, watts: 45 },
+    { name: config.presetRouter, watts: 14 },
+    { name: config.presetNas, watts: 38 },
+  ];
+  const savedState = readState();
+  const devices: Device[] = Array.isArray(savedState.devices) && savedState.devices.length > 0
+    ? savedState.devices.map((device) => ({ name: String(device.name), watts: Number(device.watts) || 0 }))
+    : defaultDevices;
+  const els = {
+    devices: root?.querySelector<HTMLElement>('[data-devices]'),
+    add: root?.querySelector<HTMLButtonElement>('[data-add-device]'),
+    battery: root?.querySelector<HTMLInputElement>('[data-battery]'),
+    efficiency: root?.querySelector<HTMLInputElement>('[data-efficiency]'),
+    efficiencyLabel: root?.querySelector<HTMLElement>('[data-efficiency-label]'),
+    powerFactor: root?.querySelector<HTMLInputElement>('[data-power-factor]'),
+    powerFactorLabel: root?.querySelector<HTMLElement>('[data-power-factor-label]'),
+    reserve: root?.querySelector<HTMLInputElement>('[data-reserve]'),
+    reserveLabel: root?.querySelector<HTMLElement>('[data-reserve-label]'),
+    totalLoad: root?.querySelector<HTMLOutputElement>('[data-total-load]'),
+    runtime: root?.querySelector<HTMLOutputElement>('[data-runtime]'),
+    runtimeBig: root?.querySelector<HTMLElement>('[data-runtime-big]'),
+    runtimeUnit: root?.querySelector<HTMLElement>('[data-runtime-unit]'),
+    recommended: root?.querySelector<HTMLOutputElement>('[data-recommended]'),
+    usableEnergy: root?.querySelector<HTMLOutputElement>('[data-usable-energy]'),
+    summary: root?.querySelector<HTMLElement>('[data-summary]'),
+    loadBar: root?.querySelector<HTMLElement>('[data-load-bar]'),
+    loadMeter: root?.querySelector<HTMLElement>('[data-load-meter]'),
+    runtimeMeter: root?.querySelector<HTMLElement>('[data-runtime-meter]'),
+    vaMeter: root?.querySelector<HTMLElement>('[data-va-meter]'),
+    energyMeter: root?.querySelector<HTMLElement>('[data-energy-meter]'),
+    trashIcon: root?.querySelector<HTMLTemplateElement>('[data-trash-icon]'),
+  };
+  applySavedControls();
+  function readState(): PersistedState {
+    try {
+      return JSON.parse(localStorage.getItem(storageKey) ?? '{}') as PersistedState;
+    } catch {
+      return {};
+    }
+  }
+  function saveState() {
+    const nextState: PersistedState = {
+      devices,
+      batteryWh: els.battery?.value,
+      efficiency: els.efficiency?.value,
+      powerFactor: els.powerFactor?.value,
+      reserve: els.reserve?.value,
+    };
+    localStorage.setItem(storageKey, JSON.stringify(nextState));
+  }
+  function applySavedControls() {
+    [
+      [els.battery, savedState.batteryWh],
+      [els.efficiency, savedState.efficiency],
+      [els.powerFactor, savedState.powerFactor],
+      [els.reserve, savedState.reserve],
+    ].forEach(([input, value]) => applySavedValue(input as HTMLInputElement | null | undefined, value as string | undefined));
+  }
+  function applySavedValue(input: HTMLInputElement | null | undefined, value: string | undefined) {
+    if (input && value) {
+      input.value = value;
+    }
+  }
+  function calculate() {
+    const stats = getRuntimeStats();
+    updateLabels();
+    updateOutputs(stats);
+    updateMeters(stats);
+    saveState();
+  }
+  function getRuntimeStats(): RuntimeStats {
+    const totalWatts = devices.reduce((sum, device) => sum + Math.max(0, device.watts), 0);
+    const batteryWh = readNumber(els.battery, 0);
+    const efficiency = readNumber(els.efficiency, 86) / 100;
+    const reserve = readNumber(els.reserve, 20) / 100;
+    const powerFactor = readNumber(els.powerFactor, 70) / 100;
+    const usableWh = batteryWh * efficiency * (1 - reserve);
+    const runtimeMinutes = totalWatts > 0 ? (usableWh / totalWatts) * 60 : 0;
+    const recommendedWatts = Math.ceil((totalWatts * 1.25) / 10) * 10;
+    const recommendedVa = Math.ceil((recommendedWatts / powerFactor) / 50) * 50;
+    return { totalWatts, usableWh, runtimeMinutes, recommendedWatts, recommendedVa };
+  }
+  function updateLabels() {
+    const efficiency = readNumber(els.efficiency, 86) / 100;
+    const reserve = readNumber(els.reserve, 20) / 100;
+    const powerFactor = readNumber(els.powerFactor, 70) / 100;
+    els.efficiencyLabel!.textContent = `${Math.round(efficiency * 100)}${config.percentUnit}`;
+    els.powerFactorLabel!.textContent = powerFactor.toFixed(2);
+    els.reserveLabel!.textContent = `${Math.round(reserve * 100)}${config.percentUnit}`;
+  }
+
+  function updateOutputs(stats: RuntimeStats) {
+    const runtimeValue = getRuntimeValue(stats.runtimeMinutes);
+    const band = getBandText(stats.runtimeMinutes);
+    els.totalLoad!.textContent = stats.totalWatts.toFixed(0);
+    els.usableEnergy!.textContent = stats.usableWh.toFixed(0);
+    els.recommended!.textContent = stats.recommendedVa.toFixed(0);
+    els.runtime!.textContent = formatRuntime(stats.runtimeMinutes);
+    els.runtimeBig!.textContent = runtimeValue.value;
+    els.runtimeUnit!.textContent = runtimeValue.unit;
+    els.summary!.textContent = `${config.summaryPrefix} ${band} ${stats.recommendedVa.toFixed(0)} ${config.vaUnit} / ${stats.recommendedWatts.toFixed(0)} ${config.wattsUnit}.`;
+  }
+
+  function updateMeters(stats: RuntimeStats) {
+    const runtimeFill = clampFill(stats.runtimeMinutes * 2, 6);
+    const loadFill = clampFill(stats.totalWatts / 8, 8);
+    const vaFill = clampFill(stats.recommendedVa / 12, 8);
+    const energyFill = clampFill(stats.usableWh / 8, 8);
+    root?.style.setProperty('--ups-fill', `${runtimeFill}%`);
+    root?.style.setProperty('--ups-load-fill', `${loadFill}%`);
+    els.loadBar!.style.width = `${loadFill}%`;
+    els.loadMeter!.style.setProperty('--meter-fill', `${loadFill}%`);
+    els.runtimeMeter!.style.setProperty('--meter-fill', `${runtimeFill}%`);
+    els.vaMeter!.style.setProperty('--meter-fill', `${vaFill}%`);
+    els.energyMeter!.style.setProperty('--meter-fill', `${energyFill}%`);
+  }
+
+  function clampFill(value: number, min: number) {
+    return Math.max(min, Math.min(100, value));
+  }
+
+  function readNumber(input: HTMLInputElement | null | undefined, fallback: number) {
+    return input ? Number(input.value) : fallback;
+  }
+
+  function getRuntimeValue(minutes: number) {
+    if (minutes >= 60) {
+      return { value: (minutes / 60).toFixed(1), unit: config.hours };
+    }
+    return { value: minutes.toFixed(0), unit: config.minutes };
+  }
+
+  function getBandText(minutes: number) {
+    if (minutes >= 30) {
+      return config.bandLight;
+    }
+    if (minutes >= 12) {
+      return config.bandBalanced;
+    }
+    return config.bandHeavy;
+  }
+
+  function formatRuntime(minutes: number): string {
+    if (minutes >= 60) return `${(minutes / 60).toFixed(1)} ${config.hours}`;
+    return `${minutes.toFixed(0)} ${config.minutes}`;
+  }
+
+  function renderDevices() {
+    els.devices!.innerHTML = '';
+    devices.forEach((device, index) => els.devices!.append(createDeviceRow(device, index)));
+  }
+
+  function createDeviceRow(device: Device, index: number) {
+    const row = document.createElement('div');
+    const nameInput = createNameInput(device, index);
+    const wattsInput = createWattsInput(device, index);
+    row.className = 'ups-device';
+    row.append(nameInput, createWattsLabel(wattsInput), createRemoveButton(index));
+    return row;
+  }
+
+  function createNameInput(device: Device, index: number) {
+    const input = document.createElement('input');
+    input.type = 'text';
+    input.className = 'ups-device-name';
+    input.ariaLabel = config.deviceName;
+    input.value = device.name;
+    input.addEventListener('input', () => {
+      devices[index]!.name = input.value;
+      saveState();
+    });
+    return input;
+  }
+
+  function createWattsInput(device: Device, index: number) {
+    const input = document.createElement('input');
+    input.type = 'number';
+    input.min = '0';
+    input.max = '2000';
+    input.step = '5';
+    input.value = String(device.watts);
+    input.addEventListener('input', () => {
+      devices[index]!.watts = Number(input.value);
+      calculate();
+    });
+    return input;
+  }
+
+  function createWattsLabel(input: HTMLInputElement) {
+    const label = document.createElement('label');
+    const text = document.createElement('span');
+    const field = document.createElement('span');
+    const unit = document.createElement('em');
+    text.textContent = config.watts;
+    field.className = 'ups-number-field';
+    unit.textContent = config.wattsUnit;
+    field.append(input, unit);
+    label.append(text, field);
+    return label;
+  }
+
+  function createRemoveButton(index: number) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.ariaLabel = config.remove;
+    appendTrashIcon(button);
+    button.addEventListener('click', () => {
+      devices.splice(index, 1);
+      renderDevices();
+      calculate();
+    });
+    return button;
+  }
+
+  function appendTrashIcon(button: HTMLButtonElement) {
+    if (els.trashIcon?.content) button.append(els.trashIcon.content.cloneNode(true));
+  }
+
+  els.add?.addEventListener('click', () => {
+    devices.push({ name: config.deviceName, watts: 25 });
+    renderDevices();
+    calculate();
+  });
+  [els.battery, els.efficiency, els.powerFactor, els.reserve].forEach((input) => input?.addEventListener('input', calculate));
+
+  renderDevices();
+  calculate();
+</script>

package/src/tool/upsRuntimeCalculator/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { UpsRuntimeCalculatorUI } from './ui';
+
+export type UpsRuntimeCalculatorLocaleContent = ToolLocaleContent<UpsRuntimeCalculatorUI>;
+
+export const upsRuntimeCalculator: HardwareToolEntry<UpsRuntimeCalculatorUI> = {
+  id: 'ups-runtime-calculator',
+  icons: {
+    bg: 'mdi:battery-clock',
+    fg: 'mdi:power-plug-battery',
+  },
+  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/upsRuntimeCalculator/i18n/de.ts

@@ -0,0 +1,208 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { UpsRuntimeCalculatorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'usv-laufzeit-rechner';
+const title = 'USV Laufzeit Rechner';
+const description = 'Berechnen Sie die USV-Batterielaufzeit, die gesamte geschützte Last, die nutzbaren Wattstunden und die empfohlene VA-Größe für PCs, Monitore, Router, NAS-Geräte und Heimlabor-Hardware.';
+
+const faqData = [
+  {
+    question: 'Wie berechne ich die USV-Laufzeit?',
+    answer: 'Addieren Sie die Wattzahl aller an der USV angeschlossenen Geräte, multiplizieren Sie die Batterie-Wattstunden der USV mit dem Wechselrichter-Wirkungsgrad, ziehen Sie die gewünschte Reserve ab und teilen Sie die nutzbaren Wattstunden durch die Last in Watt. Das Ergebnis in Stunden kann mit 60 multipliziert werden, um Minuten zu erhalten.',
+  },
+  {
+    question: 'Warum weicht die tatsächliche USV-Laufzeit von der Schätzung ab?',
+    answer: 'Die Laufzeit ändert sich mit Batteriealter, Temperatur, Entladerate, Wechselrichter-Effizienz, Lastspitzen und der Abschaltspannung des Herstellers. Betrachten Sie das Ergebnis als Planungsschätzung und überprüfen Sie es mit einem kontrollierten Abschalttest.',
+  },
+  {
+    question: 'Sollte ich eine USV nach Watt oder VA dimensionieren?',
+    answer: 'Prüfen Sie beides. Watt gibt die tatsächliche Leistung an, die die USV liefern kann, während VA den Leistungsfaktor einschließt. Eine USV muss Ihre Last in Watt übertreffen und genügend VA-Reserve für die angeschlossenen Geräte haben.',
+  },
+  {
+    question: 'Wie viel USV-Reserve sollte ich einplanen?',
+    answer: 'Ein praktisches Ziel ist es, die normale Last unter etwa 70-80 % der USV-Wattleistung zu halten. Dies lässt Raum für Anlaufspitzen, Batteriealterung und zukünftige Geräte.',
+  },
+  {
+    question: 'Kann ich Drucker oder Heizgeräte an eine USV anschließen?',
+    answer: 'Vermeiden Sie Laserdrucker, Heizgeräte und andere Lasten mit hohen Einschaltströmen, es sei denn, die USV ist ausdrücklich dafür ausgelegt. Sie können den Wechselrichter überlasten und die Laufzeit drastisch verkürzen.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Geschützte Geräte auflisten',
+    text: 'Geben Sie die Geräte ein, die bei einem Stromausfall online bleiben müssen, z. B. Computer, Monitor, Router, Modem, NAS und Netzwerk-Switch.',
+  },
+  {
+    name: 'Realistische Wattzahlen eingeben',
+    text: 'Verwenden Sie nach Möglichkeit gemessene Werte von der Steckdose. Wenn Sie nur die Nennleistung des Netzteils kennen, reduzieren Sie diese auf die erwartete Betriebslast, anstatt den maximalen Etikettenwert zu verwenden.',
+  },
+  {
+    name: 'Batteriekapazität und Annahmen festlegen',
+    text: 'Geben Sie die Batterie-Wattstunden der USV, den Wechselrichter-Wirkungsgrad, den Leistungsfaktor und die gewünschte Reserve für ein sicheres Herunterfahren ein.',
+  },
+  {
+    name: 'Laufzeit und VA-Empfehlung ablesen',
+    text: 'Verwenden Sie die geschätzten Minuten und die empfohlene VA-Größe als Kauf- oder Konfigurationsleitfaden und validieren Sie die Einrichtung mit einem sicheren Ausfalltest.',
+  },
+];
+
+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<UpsRuntimeCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'USV-Laufzeit-Rechner: Batterie-Backup-Zeit schätzen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine USV-Laufzeitschätzung beantwortet zwei praktische Fragen: Wie lange Ihre Hardware bei einem Stromausfall online bleiben kann und ob die USV groß genug für die angeschlossene Last ist. Dieser Rechner kombiniert Geräteleistung, Batterie-Wattstunden, Wechselrichter-Effizienz, Leistungsfaktor und Abschaltreserve, sodass das Ergebnis näher an der realen Planung liegt als eine einfache Division der Batteriekapazität.',
+    },
+    {
+      type: 'title',
+      text: 'Die Laufzeit-Formel',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die geschätzte Laufzeit in Stunden ist <strong>nutzbare Batterie-Wattstunden geteilt durch die Gesamtlast in W</strong>. Die nutzbaren Wattstunden entsprechen nicht der aufgedruckten Batteriekapazität: Sie sollten um Wechselrichterverluste und die gewünschte Abschaltreserve bereinigt werden. Beispielsweise liefert eine 432-Wh-Batterie bei 86 % Effizienz und 20 % Reserve etwa 297 Wh nutzbare Energie.',
+    },
+    {
+      type: 'table',
+      headers: ['Eingabe', 'Warum sie wichtig ist', 'Praktische Orientierung'],
+      rows: [
+        ['Last in Watt', 'Steuert direkt die Laufzeit', 'Nach Möglichkeit mit einem Wandmessgerät messen, insbesondere bei Gaming-PCs und NAS-Systemen.'],
+        ['Batterie-Wh', 'Bestimmt den Energievorrat', 'Herstellerangaben oder Nennspannung multipliziert mit Amperestunden verwenden.'],
+        ['Effizienz', 'Berücksichtigt Wechselrichterverluste', '80-90 % sind ein sinnvoller Planungsbereich für viele Consumer-USV-Geräte.'],
+        ['Leistungsfaktor', 'Wandelt Watt in VA um', 'USV-Spezifikation verwenden, falls bekannt; 0,6-0,8 ist bei Einsteiger- und Mittelklassegeräten üblich.'],
+        ['Reserve', 'Sichert die Abschaltmarge', '10-25 % sind sinnvoll für ein kontrolliertes Herunterfahren von PC oder Server.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Wie viel Laufzeit benötigen Sie?',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '5-10 Minuten: ausreichend, um kurze Spannungsschwankungen zu überbrücken oder einen Desktop sicher herunterzufahren.',
+        '10-20 Minuten: nützlich für Router, Modems, NAS-Geräte und kleine Heimlabor-Knoten.',
+        '30+ Minuten: besser für Netzwerkkontinuität, Remote-Arbeit und Standorte mit häufigen Ausfällen.',
+        'Mehrere Stunden: erfordert in der Regel ein größeres Batteriesystem, nicht nur eine Desktop-USV.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Watt vs. VA bei der USV-Auswahl',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'USV-Produktnamen geben häufig VA an, aber die Watt-Leistung ist die härtere Grenze für reale Geräte. Eine 900-VA-USV unterstützt möglicherweise nur 540 W, während ein anderes 900-VA-Modell 600 W oder mehr unterstützt. Prüfen Sie beide Angaben und halten Sie den Normalbetrieb unter dem Maximum, um Überlastalarme, verkürzte Batterielebensdauer und Übertragungsfehler bei einem Ausfall zu vermeiden.',
+    },
+    {
+      type: 'title',
+      text: 'Lasten, die Laufzeitschätzungen verfälschen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Gaming-PCs können in Sekunden von niedrigem Leerlaufverbrauch auf hohe GPU-Last wechseln.',
+        'Monitore variieren stark je nach Helligkeit, HDR-Modus und Bildschirmgröße.',
+        'NAS-Geräte verbrauchen beim Hochfahren der Festplatten und bei Wiederherstellungen zusätzlichen Strom.',
+        'Laserdrucker, Heizgeräte, Pumpen und Kompressoren sind schlechte USV-Lasten, sofern nicht ausdrücklich unterstützt.',
+        'Alte Batterien können deutlich weniger Laufzeit liefern, als die ursprüngliche Kapazität vermuten lässt.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Checkliste für sicheres Testen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Laden Sie die USV vor dem Test vollständig auf.',
+        'Speichern Sie offene Arbeiten und vermeiden Sie Tests während kritischer Schreibvorgänge oder Firmware-Updates.',
+        'Trennen Sie die Netzsteckdose, nicht die Geräte, und beobachten Sie USV-Lastprozentsatz und Batterieschätzung.',
+        'Stellen Sie sicher, dass Ihr PC, NAS oder Server das Abschaltsignal erhält, bevor die Batterie erschöpft ist.',
+        'Wiederholen Sie den Test alle paar Monate, da Blei-Säure-USV-Batterien schnell altern.',
+      ],
+    },
+  ],
+  ui: {
+    loadTitle: 'Geschützte Last',
+    addDevice: 'Gerät hinzufügen',
+    deviceName: 'Gerät',
+    watts: 'Watt',
+    remove: 'Gerät entfernen',
+    batteryWh: 'Batteriekapazität (Wh)',
+    efficiency: 'Wechselrichter-Effizienz',
+    powerFactor: 'Leistungsfaktor',
+    reserve: 'Abschaltreserve',
+    totalLoad: 'Gesamtlast',
+    runtime: 'Geschätzte Laufzeit',
+    recommendedUps: 'Empfohlene Größe',
+    usableEnergy: 'Nutzbare Energie',
+    minutes: 'Min.',
+    hours: 'Std.',
+    wattsUnit: 'W',
+    vaUnit: 'VA',
+    whUnit: 'Wh',
+    assumptionsLabel: 'USV-Annahmen',
+    presetDesktop: 'Desktop-PC',
+    presetMonitor: '27-Zoll-Monitor',
+    presetRouter: 'Router und Modem',
+    presetNas: 'NAS mit zwei Einschüben',
+    percentUnit: '%',
+    bandLight: 'komfortables Backup-Fenster mit einer empfohlenen USV bei etwa',
+    bandBalanced: 'ausgewogenes Backup-Fenster mit einer empfohlenen USV bei etwa',
+    bandHeavy: 'kurzes Backup-Fenster; erwägen Sie einen größeren Akku oder reduzieren Sie die Last bei etwa',
+    summaryPrefix: 'Diese Konfiguration hat ein',
+  },
+};