@jjlmoya/utils-finance 1.28.0 → 1.30.0

package/package.json

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

package/src/category/index.ts

@@ -14,10 +14,12 @@ import { legalInterestRate } from '../tool/legalInterestRate/entry';
 import { fireCalculator } from '../tool/fireCalculator/entry';
 import { debtSnowball } from '../tool/debtSnowball/entry';
 import { revolvingCardCalculator } from '../tool/revolvingCardCalculator/entry';
+import { pesetaValue } from '../tool/pesetaValue/entry';
+import { salaryEmployerCost } from '../tool/salaryEmployerCost/entry';
 
 export const financeCategory: FinanceCategoryEntry = {
   icon: 'mdi:finance',
-  tools: [compoundInterest, financialFreedom, profitability, mortgage, inflation, percentageCalculator, lateInterest, ibanBicSwift, rentIncrease, lotteryOptimizer, courtFeeCalculator, legalInterestRate, fireCalculator, debtSnowball, revolvingCardCalculator],
+  tools: [compoundInterest, financialFreedom, profitability, mortgage, inflation, percentageCalculator, lateInterest, ibanBicSwift, rentIncrease, lotteryOptimizer, courtFeeCalculator, legalInterestRate, fireCalculator, debtSnowball, revolvingCardCalculator, pesetaValue, salaryEmployerCost],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -28,6 +28,10 @@ export { rentIncrease } from './tool/rentIncreaseCalculator/entry';
 export type { RentIncreaseLocaleContent } from './tool/rentIncreaseCalculator/entry';
 export { revolvingCardCalculator } from './tool/revolvingCardCalculator/entry';
 export type { RevolvingCardCalculatorLocaleContent } from './tool/revolvingCardCalculator/entry';
+export { pesetaValue } from './tool/pesetaValue/entry';
+export type { PesetaValueLocaleContent } from './tool/pesetaValue/entry';
+export { salaryEmployerCost } from './tool/salaryEmployerCost/entry';
+export type { SalaryEmployerCostLocaleContent } from './tool/salaryEmployerCost/entry';
 export { financeCategory } from './category';
 import { compoundInterest } from './tool/compoundInterest/entry';
 import { financialFreedom } from './tool/financialFreedom/entry';
@@ -44,4 +48,6 @@ import { mortgage } from './tool/mortgage/entry';
 import { percentageCalculator } from './tool/percentageCalculator/entry';
 import { rentIncrease } from './tool/rentIncreaseCalculator/entry';
 import { revolvingCardCalculator } from './tool/revolvingCardCalculator/entry';
-export const ALL_ENTRIES = [compoundInterest, financialFreedom, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator];
+import { pesetaValue } from './tool/pesetaValue/entry';
+import { salaryEmployerCost } from './tool/salaryEmployerCost/entry';
+export const ALL_ENTRIES = [compoundInterest, financialFreedom, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator, pesetaValue, salaryEmployerCost];

package/src/index.ts

@@ -30,4 +30,5 @@ export { LEGAL_INTEREST_RATE_TOOL } from './tool/legalInterestRate';
 export { FIRE_CALCULATOR_TOOL } from './tool/fireCalculator';
 export { DEBT_SNOWBALL_TOOL } from './tool/debtSnowball';
 export { REVOLVING_CARD_CALCULATOR_TOOL } from './tool/revolvingCardCalculator';
-
+export { PESETA_VALUE_TOOL } from './tool/pesetaValue';
+export { SALARY_EMPLOYER_COST_TOOL } from './tool/salaryEmployerCost';

package/src/tests/locale_completeness.test.ts

@@ -25,8 +25,7 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('all 15 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(15);
+  it('all 17 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(17);
   });
 });
-

package/src/tests/tool_validation.test.ts

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

package/src/tool/pesetaValue/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { bibliography } from './bibliography.ts';
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+---
+
+<SharedBibliography links={bibliography} />

package/src/tool/pesetaValue/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'INE CPI national index series from 1961',
+    url: 'https://www.ine.es/jaxiT3/Tabla.htm?L=0&t=24077',
+  },
+  {
+    name: 'Official irrevocable euro conversion rates',
+    url: 'https://www.boe.es/doue/1998/359/L00001-00002.pdf',
+  },
+  {
+    name: 'Banco de España history of the peseta and its denominations',
+    url: 'https://www.bde.es/wbe/es/areas-actuacion/billetes-monedas/historia-peseta/',
+  },
+];

package/src/tool/pesetaValue/component.astro

@@ -0,0 +1,86 @@
+---
+import type { PesetaValueUI } from './ui';
+import { getSupportedYears, REFERENCE_YEAR } from './logic';
+
+interface Props {
+  ui: PesetaValueUI;
+}
+
+const { ui } = Astro.props;
+const years = getSupportedYears();
+const decades = [...new Set(years.map((year) => Math.floor(year / 10) * 10))];
+---
+
+<div class="pv-tool" data-peseta-value>
+  <script is:inline type="application/json" data-peseta-config set:html={JSON.stringify(ui)}></script>
+  <div class="pv-stage">
+    <div class="pv-controls">
+      <div class="pv-control-heading">
+        <span class="pv-eyebrow">{ui.labelAmountHint}</span>
+        <span class="pv-amount-label" data-amount-label>1,000 {ui.labelPesetas}</span>
+      </div>
+      <label class="pv-label" for="pv-amount">{ui.labelAmount}</label>
+      <div class="pv-amount-field">
+        <input id="pv-amount" data-peseta-input type="number" min="1" step="1" value="1000" inputmode="numeric" />
+        <span>{ui.labelPesetas}</span>
+      </div>
+      <div class="pv-presets" aria-label={ui.labelAmountHint}>
+        <button type="button" data-preset="100">{ui.labelPreset100}</button>
+        <button type="button" data-preset="1000" class="is-active">{ui.labelPreset1000}</button>
+        <button type="button" data-preset="10000">{ui.labelPreset10000}</button>
+        <button type="button" data-preset="100000">{ui.labelPreset100000}</button>
+      </div>
+      <div class="pv-year-control">
+        <span class="pv-label">{ui.labelOriginYear}</span>
+        <div class="pv-select" data-year-select>
+          <button type="button" class="pv-select-trigger" data-year-trigger aria-expanded="false" aria-haspopup="listbox">2000</button>
+          <div class="pv-year-menu" data-year-menu role="listbox" aria-label={ui.labelOpenYears}>
+            <div class="pv-decade-nav" role="tablist" aria-label={ui.labelDecade}>
+              {decades.map((decade) => <button type="button" data-decade={decade} class:is-active={decade === 2000} role="tab" aria-selected={decade === 2000}>{decade}s</button>)}
+            </div>
+            <div class="pv-year-grid">
+              {years.map((year) => <button type="button" data-year-option data-year={year} data-decade={Math.floor(year / 10) * 10} class:is-selected={year === 2000} role="option" aria-selected={year === 2000} hidden={Math.floor(year / 10) * 10 !== 2000}>{year}</button>)}
+            </div>
+          </div>
+        </div>
+        <input type="hidden" data-year-value value="2000" />
+        <span class="pv-help">{ui.labelOriginYearHint}</span>
+      </div>
+      <button type="button" class="pv-reset" data-reset>{ui.labelReset}</button>
+    </div>
+
+    <div class="pv-visual" aria-live="polite">
+      <div class="pv-skyline" aria-hidden="true"><span></span><span></span><span></span><span></span><span></span><span></span></div>
+      <div class="pv-cash-scene" data-cash-scene>
+        <div class="pv-cash-pieces" data-cash-pieces aria-label={ui.labelCashPieces}>
+          <div class="pv-cash-piece pv-cash-banknote pv-cash-value-1000" data-cash-initial aria-hidden="true"><strong>1,000</strong></div>
+        </div>
+        <span class="pv-cash-caption" data-cash-caption>1,000 {ui.labelPesetas}</span>
+      </div>
+      <div class="pv-orbit"><span class="pv-orbit-dot"></span></div>
+      <div class="pv-visual-caption" aria-label={ui.labelReferenceYear}><span>{ui.labelFrom} <strong data-result-origin>2000</strong></span><span>{ui.labelTo} <strong data-result-reference>{REFERENCE_YEAR}</strong></span></div>
+      <div class="pv-state"><span class="pv-state-dot"></span><span data-result-state-label>{ui.labelState}</span></div>
+    </div>
+  </div>
+
+  <div class="pv-results">
+    <div class="pv-result-main">
+      <span class="pv-result-kicker">{ui.labelTodayValue}</span>
+      <strong data-result-adjusted aria-label={ui.labelEuro}>€0.00</strong>
+      <span class="pv-result-note" data-result-change aria-label={ui.labelPurchasingPowerChange}>0.0%</span>
+    </div>
+    <div class="pv-result-grid">
+      <div><span>{ui.labelNominalEuros}</span><strong data-result-nominal>€0.00</strong></div>
+      <div><span>{ui.labelNominalDifference}</span><strong data-result-difference>€0.00</strong></div>
+      <div><span>{ui.labelConversionRate}</span><strong>166.386</strong></div>
+      <div><span>{ui.labelCpiMethod}</span><strong data-result-cpi>1.00×</strong></div>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { mountPesetaValue } from './controller';
+  const root = document.querySelector<HTMLElement>('[data-peseta-value]');
+  const config = root?.querySelector('[data-peseta-config]');
+  if (root && config?.textContent) mountPesetaValue(root, JSON.parse(config.textContent));
+</script>

package/src/tool/pesetaValue/controller.ts

@@ -0,0 +1,126 @@
+import { calculatePesetaValue, getSupportedYears, REFERENCE_YEAR } from './logic';
+import { renderEmptyPesetaValue, renderPesetaValue, formatPesetas } from './dom-views';
+import { readPesetaValueState, writePesetaValueState } from './storage';
+import type { PesetaValueUI } from './ui';
+
+interface ControllerState {
+  pesetas: number;
+  originYear: number;
+}
+
+function setActiveDecade(root: HTMLElement, decade: number): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-decade][role="tab"]').forEach((button) => {
+    const isActive = Number(button.dataset.decade) === decade;
+    button.classList.toggle('is-active', isActive);
+    button.setAttribute('aria-selected', String(isActive));
+  });
+  root.querySelectorAll<HTMLButtonElement>('[data-year-option]').forEach((option) => {
+    option.hidden = Number(option.dataset.decade) !== decade;
+  });
+}
+
+function getInput(root: HTMLElement): HTMLInputElement | null {
+  return root.querySelector<HTMLInputElement>('[data-peseta-input]');
+}
+
+function setYearMenu(root: HTMLElement, year: number, ui: PesetaValueUI): void {
+  const trigger = root.querySelector<HTMLButtonElement>('[data-year-trigger]');
+  const hidden = root.querySelector<HTMLInputElement>('[data-year-value]');
+  const options = root.querySelectorAll<HTMLButtonElement>('[data-year-option]');
+  if (trigger) trigger.textContent = String(year);
+  if (hidden) hidden.value = String(year);
+  options.forEach((option) => option.classList.toggle('is-selected', Number(option.dataset.year) === year));
+  setActiveDecade(root, Math.floor(year / 10) * 10);
+  trigger?.setAttribute('aria-label', `${ui.labelOriginYear}: ${year}`);
+}
+
+function closeYearMenu(root: HTMLElement, ui: PesetaValueUI): void {
+  const menu = root.querySelector<HTMLElement>('[data-year-menu]');
+  const trigger = root.querySelector<HTMLButtonElement>('[data-year-trigger]');
+  menu?.classList.remove('is-open');
+  menu?.setAttribute('aria-label', ui.labelOpenYears);
+  trigger?.setAttribute('aria-expanded', 'false');
+}
+
+function toggleYearMenu(root: HTMLElement, ui: PesetaValueUI): void {
+  const menu = root.querySelector<HTMLElement>('[data-year-menu]');
+  const trigger = root.querySelector<HTMLButtonElement>('[data-year-trigger]');
+  const isOpen = menu?.classList.toggle('is-open') ?? false;
+  menu?.setAttribute('aria-label', isOpen ? ui.labelCloseYears : ui.labelOpenYears);
+  trigger?.setAttribute('aria-expanded', String(isOpen));
+}
+
+function readState(root: HTMLElement): ControllerState {
+  const input = getInput(root);
+  const year = Number(root.querySelector<HTMLInputElement>('[data-year-value]')?.value ?? REFERENCE_YEAR);
+  return { pesetas: Number(input?.value ?? 1000), originYear: year };
+}
+
+function update(root: HTMLElement, ui: PesetaValueUI): void {
+  const state = readState(root);
+  const result = calculatePesetaValue(state);
+  if (result) {
+    renderPesetaValue(root, result, ui);
+    writePesetaValueState(state);
+  } else {
+    renderEmptyPesetaValue(root, ui);
+  }
+  const input = getInput(root);
+  const amountLabel = root.querySelector<HTMLElement>('[data-amount-label]');
+  if (input && amountLabel) amountLabel.textContent = `${formatPesetas(Number(input.value) || 0)} ${ui.labelPesetas}`;
+}
+
+function bindPresets(root: HTMLElement, ui: PesetaValueUI): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => {
+    button.addEventListener('click', () => {
+      const input = getInput(root);
+      if (input) input.value = button.dataset.preset ?? '1000';
+      root.querySelectorAll('[data-preset]').forEach((item) => item.classList.toggle('is-active', item === button));
+      update(root, ui);
+    });
+  });
+}
+
+function bindYearMenu(root: HTMLElement, ui: PesetaValueUI): void {
+  root.querySelector('[data-year-trigger]')?.addEventListener('click', () => toggleYearMenu(root, ui));
+  root.querySelectorAll<HTMLButtonElement>('[data-decade][role="tab"]').forEach((button) => {
+    button.addEventListener('click', () => setActiveDecade(root, Number(button.dataset.decade)));
+  });
+  root.querySelectorAll<HTMLButtonElement>('[data-year-option]').forEach((option) => {
+    option.addEventListener('click', () => {
+      setYearMenu(root, Number(option.dataset.year), ui);
+      closeYearMenu(root, ui);
+      update(root, ui);
+    });
+  });
+  document.addEventListener('click', (event) => {
+    if (!root.contains(event.target as Node)) closeYearMenu(root, ui);
+  });
+}
+
+function resetTool(root: HTMLElement, input: HTMLInputElement | null, ui: PesetaValueUI): void {
+  if (input) input.value = '1000';
+  setYearMenu(root, 2000, ui);
+  root.querySelectorAll('[data-preset]').forEach((item) => item.classList.remove('is-active'));
+  update(root, ui);
+}
+
+function restoreSavedState(root: HTMLElement, input: HTMLInputElement | null, ui: PesetaValueUI): void {
+  const saved = readPesetaValueState();
+  if (input) input.value = String(saved?.pesetas ?? 1000);
+  setYearMenu(root, saved?.originYear ?? 2000, ui);
+}
+
+export function mountPesetaValue(root: HTMLElement, ui: PesetaValueUI): void {
+  const input = getInput(root);
+  restoreSavedState(root, input, ui);
+  const changeLabel = root.querySelector<HTMLElement>('[data-result-change]');
+  changeLabel?.setAttribute('aria-label', ui.labelPurchasingPowerChange);
+  root.querySelector('[data-reset]')?.addEventListener('click', () => resetTool(root, input, ui));
+  input?.addEventListener('input', () => update(root, ui));
+  bindPresets(root, ui);
+  bindYearMenu(root, ui);
+  update(root, ui);
+  root.dataset.referenceYear = String(REFERENCE_YEAR);
+  root.dataset.availableYears = String(getSupportedYears().length);
+}

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

@@ -0,0 +1,83 @@
+import type { PesetaValueUI } from './ui';
+import { decomposePesetas, type CashPiece, type PesetaValueResult } from './logic';
+import { evaluatePesetaValue, type ValueState } from './evaluator';
+
+export function formatCurrency(value: number, ui: PesetaValueUI): string {
+  return new Intl.NumberFormat(ui.currencyLocale, {
+    style: 'currency',
+    currency: 'EUR',
+    maximumFractionDigits: 2,
+  }).format(value).replace(/\u00a0/g, ' ');
+}
+
+export function formatPesetas(value: number): string {
+  return new Intl.NumberFormat('en-GB', { maximumFractionDigits: 0 }).format(value);
+}
+
+function renderCashPiece(piece: CashPiece, ui: PesetaValueUI): HTMLElement {
+  const element = document.createElement('div');
+  const label = piece.kind === 'coin' ? ui.labelCoin : ui.labelBanknote;
+  element.className = `pv-cash-piece pv-cash-${piece.kind} pv-cash-value-${piece.value}${piece.count > 0 ? ' is-used' : ''}`;
+  element.dataset.value = String(piece.value);
+  element.setAttribute('aria-label', `${piece.count} ${label} ${formatPesetas(piece.value)} ${ui.labelPesetas}`);
+  element.dataset.count = String(piece.count);
+  const value = document.createElement('strong');
+  value.textContent = formatPesetas(piece.value);
+  element.append(value);
+  if (piece.count > 1) {
+    const count = document.createElement('small');
+    count.textContent = `${piece.count}×`;
+    element.append(count);
+  }
+  return element;
+}
+
+function renderCashScene(root: HTMLElement, result: PesetaValueResult, ui: PesetaValueUI): void {
+  const piecesRoot = root.querySelector<HTMLElement>('[data-cash-pieces]');
+  const caption = root.querySelector<HTMLElement>('[data-cash-caption]');
+  if (!piecesRoot || !caption) return;
+  piecesRoot.replaceChildren(...decomposePesetas(result.pesetas).map((piece) => renderCashPiece(piece, ui)));
+  caption.textContent = `${formatPesetas(result.pesetas)} ${ui.labelPesetas}`;
+}
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  root.querySelectorAll<HTMLElement>(selector).forEach((element) => {
+    element.textContent = value;
+  });
+}
+
+function renderDial(root: HTMLElement, result: PesetaValueResult): void {
+  const evaluation = evaluatePesetaValue(result);
+  const progress = Math.min(100, Math.max(8, result.cpiMultiplier * 12));
+  root.style.setProperty('--pv-progress', `${progress}%`);
+  root.dataset.state = evaluation.state;
+}
+
+function getStateLabel(state: ValueState, ui: PesetaValueUI): string {
+  if (state === 'positive') return ui.labelStatePositive;
+  if (state === 'negative') return ui.labelStateNegative;
+  return ui.labelStateNeutral;
+}
+
+export function renderPesetaValue(root: HTMLElement, result: PesetaValueResult, ui: PesetaValueUI): void {
+  const evaluation = evaluatePesetaValue(result);
+  setText(root, '[data-result-nominal]', formatCurrency(result.nominalEuros, ui));
+  setText(root, '[data-result-adjusted]', formatCurrency(result.adjustedEuros, ui));
+  setText(root, '[data-result-difference]', formatCurrency(result.nominalDifference, ui));
+  setText(root, '[data-result-change]', `${result.purchasingPowerChange > 0 ? '+' : ''}${result.purchasingPowerChange.toFixed(1)}%`);
+  setText(root, '[data-result-origin]', String(result.originYear));
+  setText(root, '[data-result-reference]', String(result.referenceYear));
+  setText(root, '[data-result-cpi]', `${result.cpiMultiplier.toFixed(2)}×`);
+  setText(root, '[data-result-state-label]', getStateLabel(evaluation.state, ui));
+  renderCashScene(root, result, ui);
+  renderDial(root, result);
+}
+
+export function renderEmptyPesetaValue(root: HTMLElement, ui: PesetaValueUI): void {
+  setText(root, '[data-result-nominal]', formatCurrency(0, ui));
+  setText(root, '[data-result-adjusted]', formatCurrency(0, ui));
+  setText(root, '[data-result-difference]', formatCurrency(0, ui));
+  setText(root, '[data-result-change]', '0.0%');
+  root.querySelector<HTMLElement>('[data-cash-pieces]')?.replaceChildren();
+  setText(root, '[data-cash-caption]', '');
+}

package/src/tool/pesetaValue/entry.ts

@@ -0,0 +1,31 @@
+import type { FinanceToolEntry, ToolLocaleContent } from '../../types';
+import type { PesetaValueUI } from './ui';
+
+export type PesetaValueLocaleContent = ToolLocaleContent<PesetaValueUI>;
+
+export const pesetaValue: FinanceToolEntry<PesetaValueUI> = {
+  id: 'actualizador-pesetas-ipc',
+  icons: {
+    bg: 'mdi:currency-eur',
+    fg: 'mdi:cash-multiple',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((module) => module.content),
+    de: () => import('./i18n/de').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};
+
+export { bibliography } from './bibliography';

package/src/tool/pesetaValue/evaluator.ts

@@ -0,0 +1,18 @@
+import type { PesetaValueResult } from './logic';
+
+export type ValueState = 'positive' | 'neutral' | 'negative';
+
+export interface ValueEvaluation {
+  state: ValueState;
+  ratioLabel: string;
+}
+
+export function evaluatePesetaValue(result: PesetaValueResult): ValueEvaluation {
+  if (result.purchasingPowerChange > 0.5) {
+    return { state: 'positive', ratioLabel: 'expanded' };
+  }
+  if (result.purchasingPowerChange < -0.5) {
+    return { state: 'negative', ratioLabel: 'contracted' };
+  }
+  return { state: 'neutral', ratioLabel: 'unchanged' };
+}

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

@@ -0,0 +1,54 @@
+import type { FAQPage, HowTo, SoftwareApplication, Thing, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { PesetaValueUI } from '../ui';
+
+const slug = 'peseten-in-euro-umrechner';
+const title = 'Peseten in Euro Rechner: Wert alter Peseten 2026';
+const description = 'Rechnen Sie spanische Peseten mit dem festen Kurs von 166,386 Peseten pro Euro um und vergleichen Sie die Kaufkraft bis 2026 mit dem spanischen Verbraucherpreisindex.';
+
+const faq = [
+  { question: 'Wie viel sind 1.000 Peseten in Euro?', answer: '1.000 Peseten entsprechen beim festen Umrechnungskurs 6,01 Euro. Die separate CPI-Berechnung zeigt zusätzlich, welche Kaufkraft dieser Betrag im gewählten Jahr hatte.' },
+  { question: 'Wie viel sind eine Million Peseten in Euro?', answer: 'Eine Million Peseten entsprechen 6.010,12 Euro beim festen Kurs. Die Kaufkraftschätzung für 2026 hängt vom Jahr ab, in dem der Betrag verwendet wurde.' },
+  { question: 'Wie rechnet man Peseten in Euro um?', answer: 'Teilen Sie den Pesetenbetrag durch 166,386. Zum Beispiel sind 100 Peseten 0,60 Euro und 10.000 Peseten 60,10 Euro.' },
+  { question: 'Was wären alte Peseten im Jahr 2026 wert?', answer: 'Der Rechner zeigt den festen Eurobetrag und zusätzlich eine Schätzung der durchschnittlichen Kaufkraft in 2026 anhand des spanischen Verbraucherpreisindex.' },
+  { question: 'Berechnet der Rechner den Sammlerwert von Münzen oder Scheinen?', answer: 'Nein. Er berechnet Währungsumrechnung und durchschnittliche Kaufkraft. Seltene Münzen und Banknoten können je nach Zustand, Seltenheit und Nachfrage einen anderen Marktwert haben.' },
+  { question: 'Welche Jahre verwendet der Peseten Rechner?', answer: 'Als Ursprungsjahr können Sie 1980 bis 2026 wählen. Das Bezugsjahr 2026 basiert auf den neuesten verfügbaren CPI-Daten und ist noch kein vollständiger Jahresdurchschnitt.' },
+  { question: 'Ist die Kaufkraftschätzung ein genauer Preis?', answer: 'Nein. Sie vergleicht die durchschnittliche Kaufkraft nach dem CPI und ist kein exakter Preis für Wohnen, Löhne, Lebensmittel, Energie oder einen bestimmten Kauf.' },
+];
+
+const howTo = [
+  { name: 'Betrag in Peseten eingeben', text: 'Geben Sie den Betrag von einer Quittung, einem Schein, einer Münze oder einem historischen Dokument ein.' },
+  { name: 'Jahr auswählen', text: 'Wählen Sie das Jahrzehnt und anschließend das Jahr, in dem der Betrag verwendet wurde.' },
+  { name: 'Festen Eurobetrag prüfen', text: 'Lesen Sie den nominalen Eurobetrag ab, der durch Teilen durch 166,386 entsteht.' },
+  { name: 'Kaufkraft vergleichen', text: 'Vergleichen Sie den festen Betrag mit der geschätzten durchschnittlichen Kaufkraft für 2026.' },
+];
+
+const schemas: WithContext<Thing>[] = [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) } as WithContext<FAQPage>,
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) } as WithContext<HowTo>,
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' }, inLanguage: 'de' } as WithContext<SoftwareApplication>,
+];
+
+export const content: ToolLocaleContent<PesetaValueUI> = {
+  slug, title, description,
+  ui: {
+    labelAmount: 'Historischer Betrag', labelAmountHint: 'Startpunkt wählen', labelOriginYear: 'Ursprungsjahr', labelOriginYearHint: 'Jährlicher CPI-Durchschnitt, sofern verfügbar', labelReferenceYear: 'Bezugsjahr 2026 bis heute', labelNominalEuros: 'Feste Umrechnung', labelTodayValue: 'Geschätzte Kaufkraft', labelPurchasingPowerChange: 'Veränderung der Kaufkraft', labelNominalDifference: 'Unterschied zur Umrechnung', labelConversionRate: 'Peseten pro Euro', labelCpiMethod: 'CPI-Multiplikator', labelPreset100: '100 Pta', labelPreset1000: '1.000 Pta', labelPreset10000: '10.000 Pta', labelPreset100000: '100.000 Pta', labelPesetas: 'Peseten', labelEuro: 'Euro', labelFrom: 'Von', labelTo: 'Bis', labelOpenYears: 'Ursprungsjahre öffnen', labelCloseYears: 'Ursprungsjahre schließen', labelDecade: 'Jahrzehnt wählen', labelCoin: 'Münze', labelBanknote: 'Banknote', labelCashPieces: 'Geldstücke', labelState: 'Wertentwicklung', labelStatePositive: 'gestiegen', labelStateNeutral: 'unverändert', labelStateNegative: 'gesunken', labelReset: 'Beispiel zurücksetzen', currencyLocale: 'de-DE',
+  },
+  seo: [
+    { type: 'title', text: 'Peseten in Euro: Die Antwort hängt von der Frage ab', level: 2 },
+    { type: 'paragraph', html: 'Wenn Sie einen alten Preis, Lohn, Beleg, eine Münze oder Banknote in spanischen Peseten haben, liefert dieser Rechner zwei Antworten. Er zeigt zuerst die feste Umrechnung in Euro und danach die geschätzte Kaufkraft in 2026 nach der spanischen Preisentwicklung.' },
+    { type: 'title', text: 'Häufige Umrechnungen von Peseten in Euro', level: 2 },
+    { type: 'paragraph', html: 'Der feste Kurs beträgt immer 166,386 Peseten für 1 Euro. Das Jahr ändert diesen nominalen Kurs nicht.' },
+    { type: 'table', headers: ['Alter Betrag', 'Feste Umrechnung'], rows: [['1 Pesete', '0,01 Euro'], ['25 Peseten', '0,15 Euro'], ['100 Peseten', '0,60 Euro'], ['500 Peseten', '3,01 Euro'], ['1.000 Peseten', '6,01 Euro'], ['2.000 Peseten', '12,02 Euro'], ['5.000 Peseten', '30,05 Euro'], ['10.000 Peseten', '60,10 Euro'], ['1 Million Peseten', '6.010,12 Euro']] },
+    { type: 'title', text: 'Was waren Peseten im Jahr 2026 wert?', level: 2 },
+    { type: 'paragraph', html: 'Die CPI-Schätzung beantwortet eine andere Frage als die Euro-Umrechnung. Sie schätzt, wie viele Euro im Bezugsjahr für einen ähnlichen durchschnittlichen Warenkorb nötig wären wie für den gewählten Pesetenbetrag im Ursprungsjahr. 2026 verwendet die neuesten verfügbaren Daten bis heute und ist noch kein vollständiger Jahresdurchschnitt.' },
+    { type: 'table', headers: ['Ergebnis', 'Bedeutung'], rows: [['Feste Umrechnung', 'Der nominale Eurobetrag nach dem offiziellen Kurs.'], ['CPI-bereinigter Wert', 'Eine Schätzung der durchschnittlichen Kaufkraft in 2026.'], ['Unterschied', 'Die Lücke zwischen Umrechnung und CPI-Schätzung.']] },
+    { type: 'title', text: 'So berechnen Sie einen alten Pesetenbetrag', level: 2 },
+    { type: 'list', items: ['Betrag von Beleg, Schein, Münze oder Dokument eingeben.', 'Jahr auswählen, in dem der Betrag verwendet wurde.', 'Feste Umrechnung für den direkten Eurovergleich verwenden.', 'CPI-Wert für den historischen Kaufkraftvergleich verwenden.', 'Den Unterschied als Inflationserklärung verstehen, nicht als persönliche Preisprognose.'] },
+    { type: 'title', text: 'Münzen und Banknoten haben nicht automatisch diesen Sammlerwert', level: 2 },
+    { type: 'paragraph', html: 'Dies ist ein Rechner für Währung und Inflation, kein Preisführer für Sammler. Eine seltene Pesetenmünze oder Banknote kann abhängig von Jahrgang, Zustand, Seltenheit und Nachfrage einen eigenen Marktwert haben.' },
+    { type: 'tip', title: 'Das Jahr ändert die Kaufkraft, nicht den Wechselkurs', html: 'Der feste Kurs bleibt bei 166,386 Peseten pro Euro. Nur der CPI-Vergleich ändert sich mit dem Ursprungsjahr und beschreibt einen durchschnittlichen Warenkorb.' },
+  ],
+  faq, bibliography, howTo, schemas,
+};