@jjlmoya/utils-home 1.26.0 → 1.27.0

package/package.json

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

package/src/entries.ts

@@ -18,6 +18,8 @@ export { acTonnageCalculator } from './tool/acTonnageCalculator/entry';
 export type { AcTonnageCalculatorLocaleContent } from './tool/acTonnageCalculator/entry';
 export { wallPaintingCalculator } from './tool/wallPaintingCalculator/entry';
 export type { WallPaintingCalculatorLocaleContent } from './tool/wallPaintingCalculator/entry';
+export { vampireDrawSimulator } from './tool/vampireDrawSimulator/entry';
+export type { VampireDrawSimulatorLocaleContent } from './tool/vampireDrawSimulator/entry';
 export { homeCategory } from './category';
 import { dewPointCalculator } from './tool/dewPointCalculator/entry';
 import { heatingComparator } from './tool/heatingComparator/entry';
@@ -29,4 +31,5 @@ import { tariffComparator } from './tool/tariffComparator/entry';
 import { wifiRangeSimulator } from './tool/wifiRangeSimulator/entry';
 import { acTonnageCalculator } from './tool/acTonnageCalculator/entry';
 import { wallPaintingCalculator } from './tool/wallPaintingCalculator/entry';
-export const ALL_ENTRIES = [dewPointCalculator, heatingComparator, ledSavingCalculator, projectorCalculator, qrGenerator, solarCalculator, tariffComparator, wifiRangeSimulator, acTonnageCalculator, wallPaintingCalculator];
+import { vampireDrawSimulator } from './tool/vampireDrawSimulator/entry';
+export const ALL_ENTRIES = [dewPointCalculator, heatingComparator, ledSavingCalculator, projectorCalculator, qrGenerator, solarCalculator, tariffComparator, wifiRangeSimulator, acTonnageCalculator, wallPaintingCalculator, vampireDrawSimulator];

package/src/tests/locale_completeness.test.ts

@@ -17,8 +17,8 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('should have 10 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(10);
+  it('should have 11 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(11);
   });
 });
 

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { homeCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 10 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(10);
+    it('should have 11 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(11);
     });
 
     it('homeCategory should be defined', () => {

package/src/tool/vampireDrawSimulator/bibliography.astro

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

package/src/tool/vampireDrawSimulator/bibliography.ts

@@ -0,0 +1,14 @@
+export const bibliography = [
+  {
+    name: 'Standby Power and Vampire Draw: Lawrence Berkeley National Laboratory',
+    url: 'https://standby.lbl.gov/',
+  },
+  {
+    name: 'Energy Consumption of Household Appliances: U.S. Department of Energy',
+    url: 'https://www.energy.gov/energysaver/energy-saver',
+  },
+  {
+    name: 'Phantom Load Calculator: Natural Resources Canada',
+    url: 'https://www.nrcan.gc.ca/energy-efficiency/energy-efficiency-residential/14227',
+  },
+];

package/src/tool/vampireDrawSimulator/component.astro

@@ -0,0 +1,320 @@
+---
+import type { VampireDrawSimulatorUI } from './ui';
+import { calculateVampireDraw, fmt2 } from './logic';
+
+interface Props {
+  ui?: Record<string, unknown>;
+}
+
+const { ui = {} } = Astro.props;
+const vUI = ui as VampireDrawSimulatorUI;
+
+const DEFAULT_DEVICES = [
+  { name: 'Smart TV', watts: 12, hours: 24 },
+  { name: 'Router / WiFi', watts: 8, hours: 24 },
+  { name: 'Game Console', watts: 15, hours: 24 },
+  { name: 'Desktop PC (sleep)', watts: 15, hours: 24 },
+  { name: 'Set Top Box', watts: 20, hours: 24 },
+  { name: 'Microwave (clock)', watts: 3, hours: 24 },
+  { name: 'Printer', watts: 5, hours: 24 },
+  { name: 'Phone Charger', watts: 0.5, hours: 24 },
+];
+
+const INITIAL_PRICE = 0.18;
+
+const initial = calculateVampireDraw(DEFAULT_DEVICES.map((d) => ({ name: d.name, watts: d.watts, hoursPerDay: d.hours })), INITIAL_PRICE);
+---
+
+<div class="vamp-wrapper">
+  <div class="vamp-card"
+    data-currency-sign={vUI.currencySign}
+    data-curr-usd={vUI.btnCurrUSD}
+    data-curr-eur={vUI.btnCurrEUR}
+    data-curr-gbp={vUI.btnCurrGBP}
+    data-curr-jpy={vUI.btnCurrJPY}
+    data-cat-low={vUI.categoryLow}
+    data-cat-moderate={vUI.categoryModerate}
+    data-cat-high={vUI.categoryHigh}
+    data-cat-extreme={vUI.categoryExtreme}
+  >
+    <div class="vamp-hero">
+      <div class="vamp-result-badge">{vUI.resultBadge}</div>
+      <p class="vamp-annual-label">{vUI.labelAnnualCost}</p>
+      <p class="vamp-annual-value">
+        <span id="vamp-annual-num">{fmt2(initial.annualCost)}</span>
+        <span id="vamp-annual-unit" class="vamp-annual-unit">{vUI.currencySign}</span>
+      </p>
+      <div id="vamp-category-badge" class="vamp-category-badge vamp-cat-{initial.category}">{vUI[`category${initial.category.charAt(0).toUpperCase()}${initial.category.slice(1)}` as keyof VampireDrawSimulatorUI]}</div>
+
+      <div class="vamp-stats">
+        <div class="vamp-stat">
+          <p class="vamp-stat-label">{vUI.labelAnnualKwh}</p>
+          <p id="vamp-kwh" class="vamp-stat-value">{fmt2(initial.annualKwh)} kWh</p>
+        </div>
+        <div class="vamp-stat">
+          <p class="vamp-stat-label">{vUI.labelMonthlyCost}</p>
+          <p id="vamp-monthly" class="vamp-stat-value">{vUI.currencySign}{fmt2(initial.monthlyCost)}</p>
+        </div>
+        <div class="vamp-stat">
+          <p class="vamp-stat-label">{vUI.labelTotalWatts}</p>
+          <p id="vamp-watts" class="vamp-stat-value">{initial.totalWatts} {vUI.unitWatts}</p>
+        </div>
+      </div>
+    </div>
+
+    <div class="vamp-body">
+      <p class="vamp-section-title">{vUI.sectionTitle}</p>
+      <div class="vamp-device-list" id="vamp-device-list">
+        {DEFAULT_DEVICES.map((d) => (
+          <div class="vamp-device-row" data-name={d.name} data-watts={d.watts}>
+            <span class="vamp-device-name">{d.name}</span>
+            <span class="vamp-device-watts">{d.watts} {vUI.unitWatts}</span>
+            <input type="number" class="vamp-device-hours" value={d.hours} min="0" max="24" step="1" />
+            <span class="vamp-device-watts">{vUI.unitHours}</span>
+            <button class="vamp-remove-btn">{vUI.removeDevice}</button>
+          </div>
+        ))}
+      </div>
+      <button class="vamp-add-btn" id="vamp-add-btn">+ {vUI.addDevice}</button>
+    </div>
+
+    <div class="vamp-footer">
+      <div class="vamp-field">
+        <label class="vamp-label" for="vamp-price">{vUI.labelPrice}</label>
+        <div class="vamp-price-row">
+          <input type="number" id="vamp-price" value={INITIAL_PRICE} min="0.01" step="0.01" class="vamp-price-input" />
+          <span class="vamp-price-unit" id="vamp-price-unit">{vUI.currencySign}{vUI.unitPrice}</span>
+        </div>
+      </div>
+      <div class="vamp-field vamp-currency-toggle">
+        <span class="vamp-currency-label">{vUI.labelCurrency}</span>
+        <div class="vamp-currency-btns">
+          <button class="vamp-currency-btn vamp-currency-active" data-currency="usd">{vUI.btnCurrUSD}</button>
+          <button class="vamp-currency-btn" data-currency="eur">{vUI.btnCurrEUR}</button>
+          <button class="vamp-currency-btn" data-currency="gbp">{vUI.btnCurrGBP}</button>
+          <button class="vamp-currency-btn" data-currency="jpy">{vUI.btnCurrJPY}</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="vamp-modal" id="vamp-modal" role="dialog" aria-modal="true" aria-labelledby="vamp-modal-title" style="display:none">
+    <div class="vamp-modal-backdrop" id="vamp-modal-backdrop"></div>
+    <div class="vamp-modal-card">
+      <h3 id="vamp-modal-title" class="vamp-modal-title">{vUI.modalAddTitle}</h3>
+      <div class="vamp-modal-body">
+        <div class="vamp-modal-field">
+          <label class="vamp-modal-label" for="vamp-modal-name">{vUI.labelDeviceName}</label>
+          <input type="text" id="vamp-modal-name" class="vamp-modal-input" placeholder="Smart Speaker" autocomplete="off" />
+        </div>
+        <div class="vamp-modal-field">
+          <label class="vamp-modal-label" for="vamp-modal-watts">{vUI.labelDeviceWatts}</label>
+          <input type="number" id="vamp-modal-watts" class="vamp-modal-input" value="5" min="0" step="0.1" />
+        </div>
+        <div class="vamp-modal-field">
+          <label class="vamp-modal-label" for="vamp-modal-hours">{vUI.labelHours}</label>
+          <input type="number" id="vamp-modal-hours" class="vamp-modal-input" value="24" min="0" max="24" step="1" />
+        </div>
+      </div>
+      <div class="vamp-modal-actions">
+        <button class="vamp-modal-btn vamp-modal-btn-secondary" id="vamp-modal-cancel">{vUI.btnCancel}</button>
+        <button class="vamp-modal-btn vamp-modal-btn-primary" id="vamp-modal-save">{vUI.btnSave}</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { calculateVampireDraw, fmt2 } from './logic';
+
+  const LS_KEY_CURRENCY = 'vampire-draw-currency';
+  let currency: 'usd' | 'eur' | 'gbp' | 'jpy' = 'usd';
+
+  function el(id: string) { return document.getElementById(id); }
+  function setTxt(id: string, val: string) { const e = el(id); if (e) e.textContent = val; }
+  function getNum(id: string): number { const e = el(id) as HTMLInputElement | null; return e ? parseFloat(e.value) || 0 : 0; }
+  function getStr(id: string): string { const e = el(id) as HTMLInputElement | null; return e ? e.value.trim() : ''; }
+  function getDataset(card: HTMLElement, key: string): string { return card.dataset[key] ?? ''; }
+
+  function getCurrencySign(card: HTMLElement): string {
+    const key = `curr${currency.charAt(0).toUpperCase()}${currency.slice(1)}`;
+    return getDataset(card, key) || getDataset(card, 'currencySign') || '$';
+  }
+
+  function readDevices(): { name: string; watts: number; hoursPerDay: number }[] {
+    const list = el('vamp-device-list');
+    if (!list) return [];
+    return Array.from(list.querySelectorAll('.vamp-device-row')).map((row) => {
+      const name = (row.querySelector('.vamp-device-name') as HTMLElement)?.textContent ?? '';
+      const watts = parseFloat((row as HTMLElement).dataset.watts ?? '0');
+      const hours = parseFloat((row.querySelector('.vamp-device-hours') as HTMLInputElement)?.value ?? '24');
+      return { name, watts, hoursPerDay: hours };
+    });
+  }
+
+  function updateCategoryBadge(card: HTMLElement, category: string) {
+    const badge = el('vamp-category-badge');
+    if (!badge) return;
+    badge.className = `vamp-category-badge vamp-cat-${category}`;
+    const key = `cat${category.charAt(0).toUpperCase()}${category.slice(1)}`;
+    badge.textContent = getDataset(card, key) || category;
+  }
+
+  function calculate(card: HTMLElement) {
+    const devices = readDevices();
+    const price = getNum('vamp-price');
+    const r = calculateVampireDraw(devices, price);
+    const currencySign = getCurrencySign(card);
+    setTxt('vamp-annual-num', fmt2(r.annualCost));
+    setTxt('vamp-annual-unit', currencySign);
+    setTxt('vamp-kwh', `${fmt2(r.annualKwh)} kWh`);
+    setTxt('vamp-monthly', `${currencySign}${fmt2(r.monthlyCost)}`);
+    setTxt('vamp-watts', `${r.totalWatts} W`);
+    updateCategoryBadge(card, r.category);
+  }
+
+  function clampHours(input: HTMLInputElement) {
+    let v = parseFloat(input.value);
+    if (Number.isNaN(v)) v = 0;
+    if (v < 0) v = 0;
+    if (v > 24) v = 24;
+    input.value = String(v);
+  }
+
+  function attachRowListeners(row: HTMLElement, card: HTMLElement) {
+    const hoursInput = row.querySelector('.vamp-device-hours') as HTMLInputElement | null;
+    const removeBtn = row.querySelector('.vamp-remove-btn') as HTMLButtonElement | null;
+    if (hoursInput) {
+      hoursInput.addEventListener('input', () => {
+        clampHours(hoursInput);
+        calculate(card);
+      });
+    }
+    if (removeBtn) {
+      removeBtn.addEventListener('click', () => {
+        row.remove();
+        calculate(card);
+      });
+    }
+  }
+
+  let unitW = 'W';
+  let unitH = 'h';
+  let removeLabel = 'Remove';
+
+  function textOf(sel: string, wrapper: HTMLElement | null, fallback: string): string {
+    return (wrapper?.querySelector(sel) as HTMLElement | null)?.textContent ?? fallback;
+  }
+
+  function grabUnits(wrapper: HTMLElement | null) {
+    const firstWatts = textOf('.vamp-device-watts', wrapper, '');
+    unitW = firstWatts.split(' ')[1] || 'W';
+    const allWatts = wrapper?.querySelectorAll('.vamp-device-watts');
+    unitH = (allWatts && allWatts.length > 0)
+      ? (allWatts[allWatts.length - 1] as HTMLElement).textContent ?? 'h'
+      : 'h';
+    removeLabel = textOf('.vamp-remove-btn', wrapper, 'Remove');
+  }
+
+  function createDeviceRow(name: string, watts: number, hours: number, card: HTMLElement) {
+    const list = el('vamp-device-list');
+    if (!list) return;
+    const row = document.createElement('div');
+    row.className = 'vamp-device-row';
+    row.dataset.name = name;
+    row.dataset.watts = String(watts);
+    row.innerHTML = `<span class="vamp-device-name">${name}</span><span class="vamp-device-watts">${watts} ${unitW}</span><input type="number" class="vamp-device-hours" value="${hours}" min="0" max="24" step="1" /><span class="vamp-device-watts">${unitH}</span><button class="vamp-remove-btn">${removeLabel}</button>`;
+    list.appendChild(row);
+    attachRowListeners(row, card);
+    calculate(card);
+  }
+
+  function openModal() {
+    const modal = el('vamp-modal');
+    if (!modal) return;
+    modal.style.display = '';
+    const nameIn = el('vamp-modal-name') as HTMLInputElement | null;
+    if (nameIn) { nameIn.value = ''; nameIn.focus(); }
+    const wattsIn = el('vamp-modal-watts') as HTMLInputElement | null;
+    if (wattsIn) wattsIn.value = '5';
+    const hoursIn = el('vamp-modal-hours') as HTMLInputElement | null;
+    if (hoursIn) hoursIn.value = '24';
+  }
+
+  function closeModal() {
+    const modal = el('vamp-modal');
+    if (modal) modal.style.display = 'none';
+  }
+
+  function saveModal(card: HTMLElement) {
+    const name = getStr('vamp-modal-name') || 'Device';
+    const watts = getNum('vamp-modal-watts');
+    let hours = getNum('vamp-modal-hours');
+    if (hours < 0) hours = 0;
+    if (hours > 24) hours = 24;
+    createDeviceRow(name, watts, hours, card);
+    closeModal();
+  }
+
+  function bindModalEvents(card: HTMLElement) {
+    const addBtn = el('vamp-add-btn');
+    if (addBtn) addBtn.addEventListener('click', openModal);
+    const modalBackdrop = el('vamp-modal-backdrop');
+    if (modalBackdrop) modalBackdrop.addEventListener('click', closeModal);
+    const cancelBtn = el('vamp-modal-cancel');
+    if (cancelBtn) cancelBtn.addEventListener('click', closeModal);
+    const saveBtn = el('vamp-modal-save');
+    if (saveBtn) saveBtn.addEventListener('click', () => saveModal(card));
+    const modalHoursIn = el('vamp-modal-hours') as HTMLInputElement | null;
+    if (modalHoursIn) modalHoursIn.addEventListener('input', () => clampHours(modalHoursIn));
+    document.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') closeModal();
+    });
+  }
+
+  function bindCurrencyEvents(card: HTMLElement) {
+    document.querySelectorAll('.vamp-currency-btn').forEach((btn) => {
+      btn.addEventListener('click', () => {
+        const c = (btn as HTMLElement).dataset.currency as 'usd' | 'eur' | 'gbp' | 'jpy';
+        if (c) applyCurrency(c, card);
+      });
+    });
+  }
+
+  function bindPriceEvent(card: HTMLElement) {
+    const priceInput = el('vamp-price');
+    if (priceInput) priceInput.addEventListener('input', () => calculate(card));
+  }
+
+  function init() {
+    const card = document.querySelector('.vamp-card') as HTMLElement | null;
+    if (!card) return;
+    grabUnits(card.closest('.vamp-wrapper') as HTMLElement | null);
+    const savedCurr = localStorage.getItem(LS_KEY_CURRENCY) as 'usd' | 'eur' | 'gbp' | 'jpy' | null;
+    if (savedCurr) currency = savedCurr;
+    toggleClass('.vamp-currency-btn', 'currency', currency, 'vamp-currency-active');
+    const currencySign = getCurrencySign(card);
+    setTxt('vamp-price-unit', `${currencySign}/kWh`);
+    document.querySelectorAll('.vamp-device-row').forEach((row) => attachRowListeners(row as HTMLElement, card));
+    bindModalEvents(card);
+    bindCurrencyEvents(card);
+    bindPriceEvent(card);
+    calculate(card);
+  }
+
+  function toggleClass(sel: string, attr: string, val: string, cls: string) {
+    document.querySelectorAll(sel).forEach((b) => b.classList.toggle(cls, (b as HTMLElement).dataset[attr] === val));
+  }
+
+  function applyCurrency(curr: 'usd' | 'eur' | 'gbp' | 'jpy', card: HTMLElement) {
+    currency = curr;
+    localStorage.setItem(LS_KEY_CURRENCY, curr);
+    toggleClass('.vamp-currency-btn', 'currency', curr, 'vamp-currency-active');
+    const currencySign = getCurrencySign(card);
+    setTxt('vamp-price-unit', `${currencySign}/kWh`);
+    calculate(card);
+  }
+
+  document.addEventListener('astro:page-load', init);
+  init();
+</script>

package/src/tool/vampireDrawSimulator/entry.ts

@@ -0,0 +1,29 @@
+import type { HomeToolEntry, ToolLocaleContent } from '../../types';
+import type { VampireDrawSimulatorUI } from './ui';
+
+export type VampireDrawSimulatorLocaleContent = ToolLocaleContent<VampireDrawSimulatorUI>;
+
+export const vampireDrawSimulator: HomeToolEntry<VampireDrawSimulatorUI> = {
+  id: 'vampire-draw-simulator',
+  icons: {
+    bg: 'mdi:power-plug',
+    fg: 'mdi:ghost',
+  },
+  i18n: {
+    en: async () => (await import('./i18n/en')).content,
+    es: async () => (await import('./i18n/es')).content,
+    de: async () => (await import('./i18n/de')).content,
+    fr: async () => (await import('./i18n/fr')).content,
+    it: async () => (await import('./i18n/it')).content,
+    pt: async () => (await import('./i18n/pt')).content,
+    nl: async () => (await import('./i18n/nl')).content,
+    pl: async () => (await import('./i18n/pl')).content,
+    sv: async () => (await import('./i18n/sv')).content,
+    ru: async () => (await import('./i18n/ru')).content,
+    tr: async () => (await import('./i18n/tr')).content,
+    zh: async () => (await import('./i18n/zh')).content,
+    ja: async () => (await import('./i18n/ja')).content,
+    ko: async () => (await import('./i18n/ko')).content,
+    id: async () => (await import('./i18n/id')).content,
+  },
+};

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

@@ -0,0 +1,211 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { VampireDrawSimulatorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'standby-verbrauch-simulator';
+const title = 'Standby Verbrauch Simulator';
+const description =
+  'Finden Sie heraus, wie viel Strom Ihre Geräte im Standby-Modus verschwenden. Berechnen Sie die versteckten jährlichen Kosten von Phantomlasten von Fernsehern, Routern, Ladegeräten und mehr.';
+
+const faqData = [
+  {
+    question: 'Was ist Vampire Power oder Phantomlast?',
+    answer:
+      'Vampire Power ist die Elektrizität, die elektronische Geräte verbrauchen, wenn sie ausgeschaltet oder im Standby-Modus sind. Dies geschieht, weil viele Geräte teilweise aktiv bleiben, um auf Fernbedienungen zu reagieren, Netzwerkverbindungen aufrechtzuerhalten oder interne Uhren laufen zu lassen.',
+  },
+  {
+    question: 'Wie viel kostet Standby-Strom pro Jahr?',
+    answer:
+      'Der durchschnittliche Haushalt verschwendet allein für Standby-Strom zwischen 50 und 150 Euro pro Jahr. Ein einzelner moderner Fernseher kann kontinuierlich 10 bis 20 Watt verbrauchen, was je nach Strompreis auf etwa 15 bis 30 Euro pro Jahr hinausläuft.',
+  },
+  {
+    question: 'Welche Geräte verbrauchen im Standby am meisten?',
+    answer:
+      'Die größten Verbraucher sind Set-Top-Boxen, Spielekonsolen, Desktop-Computer im Schlafmodus, Smart-TVs und ältere externe Netzteile. Kabel- und Satellitenboxen sind besonders verschwenderisch, weil sie selten in den echten Standby wechseln.',
+  },
+  {
+    question: 'Bringt das Ausstecken von Geräten wirklich Geld?',
+    answer:
+      'Ja. Das Ausstecken von Geräten oder die Verwendung von Advanced Power Strips mit Master-Steckdosen eliminiert den Standby-Verbrauch vollständig. Bei einem typischen Haushalt mit 20 Standby-Geräten kann die jährliche Einsparung zwischen 40 und 120 Euro liegen.',
+  },
+  {
+    question: 'Lohnen sich smarte Steckdosenleisten?',
+    answer:
+      'Smarte oder Advanced Power Strips schalten Strom zu Peripheriegeräten ab, wenn ein Master-Gerät ausgeschaltet wird. Sie amortisieren sich innerhalb weniger Monate, wenn man sie mit Entertainment-Centern oder Computerarbeitsplätzen nutzt.',
+  },
+  {
+    question: 'Wie kann ich den Standby-Verbrauch zu Hause messen?',
+    answer:
+      'Sie können ein preiswertes Steckdosen-Leistungsmessgerät (Wattmeter) verwenden, um exakt zu messen, wie viele Watt jedes Gerät im ausgeschalteten oder im Leerlaufzustand zieht. Alternativ liefert dieser Simulator standardisierte Schätzungen basierend auf Herstellermittelwerten und Labormessungen.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Gehen Sie jeden Raum durch',
+    text: 'Zählen Sie jedes Gerät, das rund um die Uhr eingesteckt bleibt. Dazu gehören Fernseher, Mikrowellen, Router, Drucker, Spielekonsolen und Handy-Ladegeräte.',
+  },
+  {
+    name: 'Schätzen Sie die täglichen Standby-Stunden',
+    text: 'Die meisten Geräte sind 20 bis 24 Stunden pro Tag im Standby. Geben Sie den Durchschnitt für jedes Gerät ein oder verwenden Sie den Standardwert von 24 Stunden.',
+  },
+  {
+    name: 'Geben Sie Ihren Strompreis ein',
+    text: 'Geben Sie den Preis ein, den Sie pro Kilowattstunde zahlen. Er steht auf Ihrer Stromrechnung.',
+  },
+  {
+    name: 'Lesen Sie Ihre Vampire-Draw-Zusammenfassung',
+    text: 'Der Simulator zeigt die insgesamt verschwendeten Watt, die jährlichen Kilowattstunden und die versteckten jährlichen Kosten. Verwenden Sie das Kategorie-Abzeichen, um zu sehen, ob Ihr Haushalt niedrig, moderat, hoch oder extrem ist.',
+  },
+];
+
+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) => ({
+    '@type': 'HowToStep',
+    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: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<VampireDrawSimulatorUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Phantomlast: Die Elektrizität, die Sie bezahlen, aber nie nutzen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Jede Steckdose in Ihrem Zuhause, an der ein Kabel angeschlossen ist, ist eine potenzielle Quelle von <strong>Phantomelektrizität</strong>. Auch wenn der Schalter ausgeschaltet ist, zieht das Gerät weiterhin Strom. Es sind vielleicht nur wenige Watt, multipliziert mit 24 Stunden am Tag und 365 Tagen im Jahr, werden diese Watt zu Hunderten von Kilowattstunden und zu echtem Geld, das aus Ihrer Tasche geht.',
+    },
+    {
+      type: 'stats',
+      items: [
+        { value: '5-10%', label: 'des Haushaltsbudgets', icon: 'mdi:flash' },
+        { value: '23h', label: 'Ø Standby pro Tag', icon: 'mdi:clock-outline' },
+        { value: '30W', label: 'Ø Top-Gerät', icon: 'mdi:television' },
+      ],
+      columns: 3,
+    },
+    {
+      type: 'title',
+      text: 'Die Geräte, die niemals schlafen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Moderne Haushalte enthalten durchschnittlich 40 elektronische Geräte. Etwa die Hälfte davon ist durchgehend mit dem Stromnetz verbunden. Während Energievorschriften die Standby-Effizienz in den letzten Jahren verbessert haben, ist die absolute Zahl der Geräte gestiegen. Eine einzelne Spielekonsole im Instant-On-Modus kann 15 Watt ziehen. Ein Fernseher mit Quick-Start kann 12 Watt verbrauchen. Addieren Sie Router, Modems, smarte Lautsprecher, Mikrowellen mit Uhren, Drucker und Ladegeräte, und die Summe übersteigt schnell 100 Watt dauerhaften Hintergrundverbrauchs.',
+    },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Haushalte mit geringem Verbrauch',
+          description: 'Haushalte, die den Standby-Verbrauch aktiv durch smarte Steckdosenleisten und Aussteckgewohnheiten steuern.',
+          icon: 'mdi:leaf',
+          points: ['Unter 50 Watt Gesamt-Standby', 'Jährliche Kosten unter 50 Euro', 'Verwendet Advanced Power Strips'],
+        },
+        {
+          title: 'Haushalte mit hohem Verbrauch',
+          description: 'Typische Haushalte mit Entertainment-Centern, mehreren Spielekonsolen und immer eingeschalteten Computern.',
+          icon: 'mdi:lightning-bolt',
+          points: ['Über 150 Watt Gesamt-Standby', 'Jährliche Kosten über 150 Euro', 'Viele Geräte im Quick-Start-Modus'],
+        },
+      ],
+      columns: 2,
+    },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Schnelle Spar Checkliste',
+      icon: 'mdi:check-circle',
+      badge: 'Aktion',
+      html: '<p style="margin:0">Ziehen Sie Handy-Ladegeräte bei Nichtgebrauch aus der Steckdose. Verwenden Sie eine Master-gesteuerte Steckdosenleiste für Ihr Entertainment-Center. Deaktivieren Sie den Quick-Start- oder Instant-On-Modus bei Fernsehern und Konsolen. Schalten Sie Desktop-Computer aus, anstatt sie im Schlafmodus zu lassen.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Warum Watt sich schneller summieren, als Sie denken',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein Watt ist eine Rate des Energieverbrauchs. Ein Watt, das eine Stunde lang läuft, ist eine Wattstunde. Ein Gerät, das kontinuierlich 10 Watt zieht, verbraucht 87,6 Kilowattstunden pro Jahr. Bei einem Durchschnittspreis von 0,25 Euro pro Kilowattstunde kostet dieses einzelne Gerät über 21 Euro pro Jahr. Multiplizieren Sie das nun mit jedem eingesteckten Gadget in Ihrem Zuhause.',
+    },
+    {
+      type: 'summary',
+      title: 'So senken Sie Ihre Phantomlast',
+      items: [
+        'Ermitteln Sie die größten Verbraucher mit diesem Simulator oder einem Steckdosen-Messgerät.',
+        'Gruppieren Sie Geräte auf smarten Steckdosenleisten, die den Standby abschalten, wenn das Hauptgerät aus ist.',
+        'Deaktivieren Sie Always-On-, Quick-Start- und Netzwerk-Standby-Funktionen, wo möglich.',
+        'Ziehen Sie Ladegeräte und kleine Geräte ab, die nicht täglich genutzt werden.',
+        'Erwägen Sie den Ersatz sehr alter externer Netzteile durch moderne, effiziente Modelle.',
+      ],
+    },
+  ],
+  ui: {
+    sectionTitle: 'Phantom-Last-Audit',
+    labelDevices: 'Angeschlossene Standby-Geräte',
+    labelHours: 'Standby-Stunden pro Tag',
+    unitHours: 'h',
+    labelPrice: 'Strompreis',
+    unitPrice: '/kWh',
+    resultBadge: 'Vampire-Draw-Ergebnis',
+    labelAnnualKwh: 'Pro Jahr verschwendet',
+    labelAnnualCost: 'Versteckte jährliche Kosten',
+    labelMonthlyCost: 'Monatliches Äquivalent',
+    labelDevicesCount: 'Geräte gezählt',
+    labelTotalWatts: 'Gesamt-Standby-Watt',
+    unitWatts: 'W',
+    currencySign: '$',
+    labelCurrency: 'Währung',
+    btnCurrUSD: '$',
+    btnCurrEUR: '€',
+    btnCurrGBP: '£',
+    btnCurrJPY: '¥',
+    categoryLow: 'Geringer Verbrauch',
+    categoryModerate: 'Moderater Verbrauch',
+    categoryHigh: 'Hoher Verbrauch',
+    categoryExtreme: 'Extremer Verbrauch',
+    addDevice: 'Gerät hinzufügen',
+    removeDevice: 'Entfernen',
+    modalAddTitle: 'Standby-Gerät hinzufügen',
+    labelDeviceName: 'Gerätename',
+    labelDeviceWatts: 'Watt im Standby',
+    btnSave: 'Speichern',
+    btnCancel: 'Abbrechen',
+  },
+};