@jjlmoya/utils-finance 1.34.0 → 1.36.0

package/package.json

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

package/src/category/index.ts

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

package/src/entries.ts

@@ -34,6 +34,8 @@ export { salaryEmployerCost } from './tool/salaryEmployerCost/entry';
 export type { SalaryEmployerCostLocaleContent } from './tool/salaryEmployerCost/entry';
 export { dividendYield } from './tool/dividendYield/entry';
 export type { DividendYieldLocaleContent } from './tool/dividendYield/entry';
+export { inflationPurchasingPower } from './tool/inflationPurchasingPower/entry';
+export type { InflationPurchasingPowerLocaleContent } from './tool/inflationPurchasingPower/entry';
 export { financeCategory } from './category';
 import { compoundInterest } from './tool/compoundInterest/entry';
 import { financialFreedom } from './tool/financialFreedom/entry';
@@ -53,4 +55,6 @@ import { revolvingCardCalculator } from './tool/revolvingCardCalculator/entry';
 import { pesetaValue } from './tool/pesetaValue/entry';
 import { salaryEmployerCost } from './tool/salaryEmployerCost/entry';
 import { dividendYield } from './tool/dividendYield/entry';
-export const ALL_ENTRIES = [compoundInterest, financialFreedom, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator, pesetaValue, salaryEmployerCost, dividendYield];
+import { mortgageExtraPaymentPlanner } from './tool/mortgageExtraPaymentPlanner/entry';
+import { inflationPurchasingPower } from './tool/inflationPurchasingPower/entry';
+export const ALL_ENTRIES = [compoundInterest, financialFreedom, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator, pesetaValue, salaryEmployerCost, dividendYield, mortgageExtraPaymentPlanner, inflationPurchasingPower];

package/src/index.ts

@@ -33,3 +33,4 @@ export { REVOLVING_CARD_CALCULATOR_TOOL } from './tool/revolvingCardCalculator';
 export { PESETA_VALUE_TOOL } from './tool/pesetaValue';
 export { SALARY_EMPLOYER_COST_TOOL } from './tool/salaryEmployerCost';
 export { DIVIDEND_YIELD_TOOL } from './tool/dividendYield';
+export { MORTGAGE_EXTRA_PAYMENT_PLANNER_TOOL } from './tool/mortgageExtraPaymentPlanner';

package/src/pages/[locale]/[slug].astro

@@ -124,7 +124,7 @@ const titleBase = words.slice(1).join(" ") || "";
     />
 
     <section class="section-tool">
-      <Component ui={content.ui} />
+      <Component ui={content.ui} locale={locale} />
     </section>
 
     <section class="section-seo">

package/src/tests/locale_completeness.test.ts

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

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 18 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(18);
+    it('should have 20 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(20);
     });
 
     it('financeCategory should be defined', () => {

package/src/tool/inflationPurchasingPower/bibliography.astro

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

package/src/tool/inflationPurchasingPower/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Banco de España, ¿Qué es la inflación?',
+    url: 'https://www.bde.es/wbe/es/areas-actuacion/politica-monetaria/preguntas-frecuentes/politica-monetaria-y-estabilidad-precios/que-es-la-inflacion.html',
+  },
+  {
+    name: 'Bank of Canada, Inflation Calculator',
+    url: 'https://www.bankofcanada.ca/rates/related/inflation-calculator/',
+  },
+];

package/src/tool/inflationPurchasingPower/component.astro

@@ -0,0 +1,79 @@
+---
+import type { InflationPurchasingPowerUI } from './ui';
+import type { InflationPurchasingPowerInput } from './logic';
+import { calculateInflationTimeline } from './logic';
+import { renderTimelineResults, renderTimelineScene } from './dom-views';
+import './inflation-purchasing-power-timeline.css';
+
+interface Props {
+  ui: InflationPurchasingPowerUI;
+  locale?: string;
+}
+
+const { ui } = Astro.props;
+const initial: InflationPurchasingPowerInput = {
+  startingAmount: 1000,
+  annualInflationRate: 2.5,
+  years: 20,
+  annualCashFlow: 0,
+  cashFlowMode: 'none',
+};
+const initialResult = calculateInflationTimeline(initial);
+const config = JSON.stringify({ ui, initial });
+---
+
+<div class="inflation-purchasing-power-tool" data-ipp-tool>
+  <form class="ipp-controls" aria-label="Inflation purchasing power inputs">
+    <div class="ipp-field">
+      <label for="ipp-amount">{ui.amountLabel}</label>
+      <input id="ipp-amount" data-ipp-input="amount" type="number" min="0.01" step="0.01" value={initial.startingAmount} inputmode="decimal" />
+      <small>{ui.amountHelp}</small>
+    </div>
+    <div class="ipp-field">
+      <label for="ipp-inflation">{ui.inflationLabel}</label>
+      <input id="ipp-inflation" data-ipp-input="inflation" type="number" min="-99.99" max="100" step="0.1" value={initial.annualInflationRate} inputmode="decimal" />
+      <small>{ui.inflationHelp}</small>
+    </div>
+    <div class="ipp-field">
+      <label for="ipp-years">{ui.yearsLabel}</label>
+      <input id="ipp-years" data-ipp-input="years" type="number" min="1" max="80" step="1" value={initial.years} inputmode="numeric" />
+      <small>{ui.yearsHelp}</small>
+    </div>
+    <div class="ipp-field">
+      <label for="ipp-cash-flow">{ui.cashFlowLabel}</label>
+      <input id="ipp-cash-flow" data-ipp-input="cash-flow" type="number" min="0" step="0.01" value={initial.annualCashFlow} inputmode="decimal" disabled />
+      <small>{ui.cashFlowHelp}</small>
+    </div>
+    <fieldset class="ipp-flow">
+      <legend>{ui.cashFlowModeLabel}</legend>
+      <div class="ipp-flow-options">
+        <button type="button" data-ipp-mode="none" class="is-active" aria-pressed="true">{ui.noCashFlowOption}</button>
+        <button type="button" data-ipp-mode="contribution" aria-pressed="false">{ui.contributionOption}</button>
+        <button type="button" data-ipp-mode="withdrawal" aria-pressed="false">{ui.withdrawalOption}</button>
+      </div>
+    </fieldset>
+  </form>
+
+  <section class="ipp-output" aria-live="polite">
+    <div class="ipp-scene-wrap" data-ipp-scene set:html={initialResult ? renderTimelineScene(initialResult, ui) : ''}></div>
+    <div class="ipp-result-wrap" data-ipp-results set:html={initialResult ? renderTimelineResults(initialResult, ui) : ''}></div>
+    <p class="ipp-error" data-ipp-error hidden>{ui.emptyMessage}</p>
+  </section>
+
+  <details class="ipp-method">
+    <summary>{ui.methodTitle}</summary>
+    <p>{ui.methodText}</p>
+    <p>{ui.limitationText}</p>
+  </details>
+</div>
+
+<script is:inline type="application/json" data-ipp-config set:html={config}></script>
+<script>
+  import { initInflationPurchasingPower } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-ipp-tool]');
+  const configElement = document.querySelector<HTMLScriptElement>('[data-ipp-config]');
+  if (root && configElement?.textContent) {
+    initInflationPurchasingPower(root, JSON.parse(configElement.textContent));
+  }
+</script>

package/src/tool/inflationPurchasingPower/controller.ts

@@ -0,0 +1,82 @@
+import { calculateInflationTimeline, type CashFlowMode, type InflationPurchasingPowerInput } from './logic';
+import { renderTimelineResults, renderTimelineScene } from './dom-views';
+import { loadInflationPurchasingPowerState, saveInflationPurchasingPowerState } from './storage';
+import type { InflationPurchasingPowerUI } from './ui';
+
+interface Config {
+  ui: InflationPurchasingPowerUI;
+  initial: InflationPurchasingPowerInput;
+}
+
+function readNumber(root: HTMLElement, name: string): number {
+  const field = root.querySelector<HTMLInputElement>(`[data-ipp-input="${name}"]`);
+  return field?.value === '' ? Number.NaN : Number(field?.value);
+}
+
+function collectState(root: HTMLElement): InflationPurchasingPowerInput {
+  const activeMode = root.querySelector<HTMLButtonElement>('[data-ipp-mode].is-active')?.dataset.ippMode;
+  return {
+    startingAmount: readNumber(root, 'amount'),
+    annualInflationRate: readNumber(root, 'inflation'),
+    years: readNumber(root, 'years'),
+    annualCashFlow: readNumber(root, 'cash-flow'),
+    cashFlowMode: activeMode === 'contribution' || activeMode === 'withdrawal' ? activeMode : 'none',
+  };
+}
+
+function setMode(root: HTMLElement, mode: CashFlowMode): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-ipp-mode]').forEach((button) => {
+    const isActive = button.dataset.ippMode === mode;
+    button.classList.toggle('is-active', isActive);
+    button.setAttribute('aria-pressed', String(isActive));
+  });
+  const cashFlowField = root.querySelector<HTMLInputElement>('[data-ipp-input="cash-flow"]');
+  if (cashFlowField) cashFlowField.disabled = mode === 'none';
+}
+
+function setInputValues(root: HTMLElement, state: InflationPurchasingPowerInput): void {
+  const values: Record<string, number> = { amount: state.startingAmount, inflation: state.annualInflationRate, years: state.years, 'cash-flow': state.annualCashFlow };
+  Object.entries(values).forEach(([name, value]) => {
+    const field = root.querySelector<HTMLInputElement>(`[data-ipp-input="${name}"]`);
+    if (field) field.value = String(value);
+  });
+  setMode(root, state.cashFlowMode);
+}
+
+function render(root: HTMLElement, state: InflationPurchasingPowerInput, ui: InflationPurchasingPowerUI): void {
+  const result = calculateInflationTimeline(state);
+  const scene = root.querySelector<HTMLElement>('[data-ipp-scene]');
+  const results = root.querySelector<HTMLElement>('[data-ipp-results]');
+  const error = root.querySelector<HTMLElement>('[data-ipp-error]');
+  if (!scene || !results || !error) return;
+  if (!result) {
+    scene.innerHTML = '';
+    results.innerHTML = '';
+    error.hidden = false;
+    return;
+  }
+  error.hidden = true;
+  scene.innerHTML = renderTimelineScene(result, ui);
+  results.innerHTML = renderTimelineResults(result, ui);
+}
+
+export function initInflationPurchasingPower(root: HTMLElement, config: Config): void {
+  const initialState = loadInflationPurchasingPowerState(config.initial);
+  setInputValues(root, initialState);
+  render(root, initialState, config.ui);
+  root.addEventListener('input', () => {
+    const state = collectState(root);
+    if (calculateInflationTimeline(state)) saveInflationPurchasingPowerState(state);
+    render(root, state, config.ui);
+  });
+  root.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    const button = target.closest<HTMLButtonElement>('[data-ipp-mode]');
+    const mode = button?.dataset.ippMode as CashFlowMode | undefined;
+    if (!button || !mode) return;
+    setMode(root, mode);
+    const state = collectState(root);
+    saveInflationPurchasingPowerState(state);
+    render(root, state, config.ui);
+  });
+}

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

@@ -0,0 +1,99 @@
+import type { InflationPurchasingPowerResult, InflationTimelinePoint } from './logic';
+import { evaluateInflationTimeline } from './evaluator';
+import type { InflationPurchasingPowerUI } from './ui';
+
+const numberFormat = new Intl.NumberFormat('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+
+export function formatAmount(value: number): string {
+  return numberFormat.format(value);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] ?? character);
+}
+
+function getChartBounds(result: InflationPurchasingPowerResult): { min: number; max: number } {
+  const values = result.points.flatMap((point) => [point.costEquivalent, point.unchangedRealValue, point.realBalance]);
+  const max = Math.max(...values, result.input.startingAmount) * 1.08;
+  const min = Math.max(0, Math.min(...values) * 0.92);
+  return { min, max: max === min ? min + 1 : max };
+}
+
+function createPath(points: InflationTimelinePoint[], value: (point: InflationTimelinePoint) => number, bounds: { min: number; max: number }): string {
+  const chartWidth = 560;
+  const chartHeight = 220;
+  return points.map((point, index) => {
+    const x = 70 + (index / Math.max(points.length - 1, 1)) * chartWidth;
+    const y = 275 - ((value(point) - bounds.min) / (bounds.max - bounds.min)) * chartHeight;
+    return `${index === 0 ? 'M' : 'L'} ${x.toFixed(1)} ${Math.max(40, Math.min(275, y)).toFixed(1)}`;
+  }).join(' ');
+}
+
+function renderLegend(label: string, className: string): string {
+  return `<span class="ipp-legend-item"><i class="ipp-legend-line ${className}"></i>${escapeHtml(label)}</span>`;
+}
+
+function getEndY(value: number, bounds: { min: number; max: number }): string {
+  return Math.max(40, Math.min(275, 275 - ((value - bounds.min) / (bounds.max - bounds.min)) * 220)).toFixed(1);
+}
+
+function renderChart(result: InflationPurchasingPowerResult, ui: InflationPurchasingPowerUI): string {
+  const bounds = getChartBounds(result);
+  const costPath = createPath(result.points, (point) => point.costEquivalent, bounds);
+  const realPath = createPath(result.points, (point) => point.unchangedRealValue, bounds);
+  const balancePath = createPath(result.points, (point) => point.realBalance, bounds);
+  const end = result.points.at(-1);
+  if (!end) return '';
+  return `<svg class="ipp-chart" viewBox="0 0 700 340" role="img" aria-label="${escapeHtml(ui.chartDescription)}">
+    <line class="ipp-grid-line" x1="70" y1="95" x2="630" y2="95" />
+    <line class="ipp-grid-line" x1="70" y1="185" x2="630" y2="185" />
+    <line class="ipp-axis" x1="70" y1="275" x2="630" y2="275" />
+    <path class="ipp-line ipp-line-cost" d="${costPath}" />
+    <path class="ipp-line ipp-line-real" d="${realPath}" />
+    <path class="ipp-line ipp-line-balance" d="${balancePath}" />
+    <circle class="ipp-end-dot ipp-dot-cost" cx="630" cy="${getEndY(end.costEquivalent, bounds)}" r="6" />
+    <circle class="ipp-end-dot ipp-dot-real" cx="630" cy="${getEndY(end.unchangedRealValue, bounds)}" r="6" />
+    <text class="ipp-axis-label" x="70" y="310">${escapeHtml(ui.todayLabel)}</text>
+    <text class="ipp-axis-label" x="630" y="310" text-anchor="end">${escapeHtml(ui.endLabel)}</text>
+    <text class="ipp-chart-caption" x="70" y="28">${escapeHtml(ui.chartNote)}</text>
+  </svg>`;
+}
+
+export function renderTimelineScene(result: InflationPurchasingPowerResult, ui: InflationPurchasingPowerUI): string {
+  const evaluation = evaluateInflationTimeline(result, ui);
+  return `<div class="ipp-scene" data-ipp-tone="${evaluation.tone}">
+    <div class="ipp-scene-heading">
+      <span>${escapeHtml(ui.todayLabel)}</span>
+      <span class="ipp-scene-rule"></span>
+      <span>${escapeHtml(ui.endLabel)}</span>
+    </div>
+    ${renderChart(result, ui)}
+    <div class="ipp-legend" aria-label="${escapeHtml(ui.chartDescription)}">
+      ${renderLegend(ui.costLineLabel, 'ipp-legend-cost')}
+      ${renderLegend(ui.realLineLabel, 'ipp-legend-real')}
+      ${renderLegend(ui.balanceLineLabel, 'ipp-legend-balance')}
+    </div>
+  </div>`;
+}
+
+function renderMetric(label: string, value: string, className = ''): string {
+  return `<div class="ipp-metric ${className}"><span>${escapeHtml(label)}</span><strong>${escapeHtml(value)}</strong></div>`;
+}
+
+export function renderTimelineResults(result: InflationPurchasingPowerResult, ui: InflationPurchasingPowerUI): string {
+  const end = result.points.at(-1);
+  if (!end) return '';
+  const evaluation = evaluateInflationTimeline(result, ui);
+  const rows = result.milestones.map((point) => `<tr><th scope="row">${point.year}</th><td>${formatAmount(point.costEquivalent)}</td><td>${formatAmount(point.unchangedRealValue)}</td><td>${formatAmount(point.realBalance)}</td></tr>`).join('');
+  return `<div class="ipp-result-content">
+    <div class="ipp-primary-metric"><span>${escapeHtml(ui.costEquivalentLabel)}</span><strong>${formatAmount(end.costEquivalent)}</strong><small>${escapeHtml(ui.amountSuffix)}</small></div>
+    <div class="ipp-metrics">
+      ${renderMetric(ui.realValueLabel, formatAmount(end.unchangedRealValue))}
+      ${renderMetric(ui.nominalBalanceLabel, formatAmount(end.nominalBalance))}
+      ${renderMetric(ui.purchasingPowerLossLabel, `${result.purchasingPowerLossPercent.toFixed(1)}%`, 'ipp-metric-accent')}
+    </div>
+    <p class="ipp-scenario" data-ipp-tone="${evaluation.tone}">${escapeHtml(evaluation.message)}</p>
+    <h3>${escapeHtml(ui.milestoneTitle)}</h3>
+    <div class="ipp-table-wrap"><table><thead><tr><th scope="col">${escapeHtml(ui.yearHeader)}</th><th scope="col">${escapeHtml(ui.costHeader)}</th><th scope="col">${escapeHtml(ui.realHeader)}</th><th scope="col">${escapeHtml(ui.balanceHeader)}</th></tr></thead><tbody>${rows}</tbody></table></div>
+  </div>`;
+}

package/src/tool/inflationPurchasingPower/entry.ts

@@ -0,0 +1,31 @@
+import type { FinanceToolEntry, ToolLocaleContent } from '../../types';
+import type { InflationPurchasingPowerUI } from './ui';
+
+export type InflationPurchasingPowerLocaleContent = ToolLocaleContent<InflationPurchasingPowerUI>;
+
+export const inflationPurchasingPower: FinanceToolEntry<InflationPurchasingPowerUI> = {
+  id: 'inflation-purchasing-power-timeline',
+  icons: {
+    bg: 'mdi:chart-timeline-variant-shimmer',
+    fg: 'mdi:cash-sync',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    de: () => import('./i18n/de').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),
+  },
+};
+
+export { bibliography } from './bibliography';

package/src/tool/inflationPurchasingPower/evaluator.ts

@@ -0,0 +1,18 @@
+import type { InflationPurchasingPowerResult } from './logic';
+import type { InflationPurchasingPowerUI } from './ui';
+
+export type TimelineTone = 'neutral' | 'warning';
+
+export interface TimelineEvaluation {
+  tone: TimelineTone;
+  message: string;
+}
+
+export function evaluateInflationTimeline(result: InflationPurchasingPowerResult, ui: InflationPurchasingPowerUI): TimelineEvaluation {
+  if (result.depletionYear !== null) {
+    return { tone: 'warning', message: ui.depletionWarning.replace('{year}', String(result.depletionYear)) };
+  }
+  if (result.input.cashFlowMode === 'contribution') return { tone: 'neutral', message: ui.contributionSummary };
+  if (result.input.cashFlowMode === 'withdrawal') return { tone: 'warning', message: ui.withdrawalSummary };
+  return { tone: 'neutral', message: ui.noCashFlowSummary };
+}

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

@@ -0,0 +1,56 @@
+import { bibliography } from '../bibliography';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { InflationPurchasingPowerUI } from '../ui';
+
+const title = 'Rechner für Inflation und Kaufkraft im Zeitverlauf';
+const description = 'Zeigt, wie eine jährliche Inflationsannahme den benötigten Betrag für dieselbe Kaufkraft und den realen Wert von Bargeld verändert.';
+const ui: InflationPurchasingPowerUI = {
+  amountLabel: 'Startbetrag', amountHelp: 'Beliebige Waehrung verwenden und beibehalten',
+  inflationLabel: 'Jaehrliche Inflationsrate (%)', inflationHelp: 'Eine Szenarioannahme, keine Prognose',
+  yearsLabel: 'Zeitraum (Jahre)', yearsHelp: 'Von 1 bis 80 Jahre waehlen',
+  cashFlowLabel: 'Jaehrlicher Cashflow', cashFlowHelp: 'Wird jedes Jahr zum Guthaben addiert oder davon abgezogen',
+  cashFlowModeLabel: 'Cashflow-Szenario', noCashFlowOption: 'Kein regelmaessiger Cashflow', contributionOption: 'Jedes Jahr einzahlen', withdrawalOption: 'Jedes Jahr entnehmen',
+  costEquivalentLabel: 'Kostenwert am Ende', realValueLabel: 'Endwert in heutigem Geld', nominalBalanceLabel: 'Nominales Endguthaben', purchasingPowerLossLabel: 'Verlorene Kaufkraft',
+  todayLabel: 'Heute', endLabel: 'Ende des Zeitraums', costLineLabel: 'Kosten fuer denselben Warenkorb', realLineLabel: 'Unveraenderte Kaufkraft des Bargelds', balanceLineLabel: 'Szenarioguthaben in heutigem Geld',
+  chartDescription: 'Inflationsverlauf mit steigenden Kosten, sinkender Kaufkraft und Szenarioguthaben', chartNote: 'Jede Linie wird am Startbetrag gemessen', milestoneTitle: 'Meilensteine in derselben Waehrung',
+  yearHeader: 'Jahr', costHeader: 'Kostenwert', realHeader: 'Unveraendertes Bargeld', balanceHeader: 'Reales Guthaben', methodTitle: 'So funktioniert der Zeitverlauf',
+  methodText: 'Der Kostenwert ist der Startbetrag multipliziert mit (1 + jaehrliche Inflationsrate) hoch der Jahreszahl. Der Wert unveraenderten Bargelds ist der Startbetrag geteilt durch denselben Faktor. Einzahlungen werden am Jahresende addiert, Entnahmen abgezogen; das Guthaben endet bei null.',
+  limitationText: 'Dies ist ein transparentes Szenariomodell, keine historische CPI-Abfrage, Renditeprognose oder persoenliche Finanzberatung. Dein Warenkorb kann von einem veroeffentlichten Verbraucherpreisindex abweichen, und die tatsaechliche Inflation kann sich jaehrlich aendern.',
+  emptyMessage: 'Gib einen positiven Betrag, eine Rate ueber -100 %, eine ganze Jahreszahl von 1 bis 80 und einen nicht negativen Cashflow ein.', contributionSummary: 'Die gestrichelte Linie zeigt den heutigen Wert des Guthabens nach den regelmaessigen Einzahlungen ohne Anlagerendite.', withdrawalSummary: 'Die gestrichelte Linie zeigt den heutigen Wert des Guthabens nach den regelmaessigen Entnahmen ohne Anlagerendite.', noCashFlowSummary: 'Die durchgezogenen Linien zeigen nur die Inflation: eine die kuenftigen Kosten desselben Warenkorbs, die andere die Kaufkraft unveraenderten Bargelds.', depletionWarning: 'Das Entnahmeszenario erreicht im Jahr {year} null; danach bleibt es bei null.',
+  scenarioNote: 'Nur ein Szenario', currencyHint: 'Dieselbe Waehrung wie der Startbetrag', yearsSuffix: 'Jahre', amountSuffix: 'in derselben Waehrung wie dein Startbetrag',
+};
+const faq = [
+  { question: 'Wie senkt Inflation die Kaufkraft?', answer: 'Wenn das allgemeine Preisniveau steigt, kauft derselbe Betrag weniger Waren und Dienstleistungen. Der Rechner zeigt diesen Effekt, indem er unveraendertes Bargeld durch den kumulierten Inflationsfaktor teilt.' },
+  { question: 'Was ist der Unterschied zwischen Kostenwert und Realwert?', answer: 'Der Kostenwert ist der kuenftige Betrag fuer denselben Warenkorb. Der Realwert zeigt, was der unveraenderte Startbetrag am Ende in heutigem Geld kaufen kann.' },
+  { question: 'Was enthalten Einzahlungs- und Entnahmeszenarien?', answer: 'Der Cashflow wird am Ende jedes Jahres addiert oder abgezogen. Renditen, Steuern, Gebuehren und Zinsen sind nicht enthalten; Entnahmen koennen das Guthaben nicht unter null senken.' },
+  { question: 'Ist die Inflationsrate eine Vorhersage?', answer: 'Nein. Sie ist eine Annahme zur Sensitivitaetsanalyse. Die tatsaechliche Inflation kann abweichen, ebenso wie dein persoenlicher Warenkorb.' },
+];
+const howTo = [
+  { name: 'Startbetrag eingeben', text: 'Verwende den Betrag, dessen kuenftige Kaufkraft du untersuchen willst, und bleibe bei einer Waehrung.' },
+  { name: 'Inflationsszenario festlegen', text: 'Gib eine jaehrliche Rate und einen ganzen Zeitraum ein. Vergleiche mehrere Raten, statt dich auf eine Annahme zu verlassen.' },
+  { name: 'Optionalen Cashflow hinzufuegen', text: 'Waehle Einzahlen oder Entnehmen und gib den wiederkehrenden Betrag ein. Ohne regelmaessigen Cashflow bleibt nur der Inflationseffekt.' },
+  { name: 'Kurven und Meilensteine lesen', text: 'Vergleiche Kostenwert und Endwert in heutigem Geld. Die Tabelle zeigt, wann die Luecke deutlich wird.' },
+];
+const faqSchema: WithContext<FAQPage> = { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.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: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) };
+const appSchema: WithContext<SoftwareApplication> = { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' }, inLanguage: 'de' };
+const seo = [
+  { type: 'title' as const, text: 'Inflationsverlauf fuer eine bessere Kaufkraftplanung', level: 2 },
+  { type: 'paragraph' as const, html: '<p>Inflation veraendert das Preisniveau. Ein unveraenderter Geldbetrag kann deshalb spaeter weniger kaufen. Dieser Rechner trennt die benoetigten Kosten fuer denselben Warenkorb von der Kaufkraft, die Bargeld behaelt.</p>' },
+  { type: 'paragraph' as const, html: '<p>Gib Startbetrag, jaehrliche Inflationsannahme und Zeitraum ein. Die Rate wird jedes Jahr kumuliert. Die Ergebnisse bleiben in derselben Waehrung und behaupten nicht, den kuenftigen Preisverlauf zu kennen.</p>' },
+  { type: 'title' as const, text: 'Die zwei wichtigsten Werte', level: 3 },
+  { type: 'table' as const, headers: ['Wert', 'Formel', 'Frage'], rows: [['Kostenwert', 'Startbetrag x (1 + Inflationsrate)^Jahre', 'Wie viel kostet derselbe Warenkorb am Ende?'], ['Kaufkraft von Bargeld', 'Startbetrag / (1 + Inflationsrate)^Jahre', 'Was kann der alte Betrag in heutigem Geld kaufen?'], ['Verlorene Kaufkraft', '(1 - 1 / Preisfaktor) x 100', 'Welcher Anteil der Kaufkraft fehlt?']] },
+  { type: 'paragraph' as const, html: '<p>Bei 3 % Inflation werden aus 1.000 nach zehn Jahren ungefaehr 1.344 Kostenwert. Bleibt der Betrag als Bargeld unveraendert, entspricht seine Kaufkraft dann etwa 744 in heutigem Geld.</p>' },
+  { type: 'title' as const, text: 'Warum die Aufzinsung zaehlt', level: 3 },
+  { type: 'paragraph' as const, html: '<p>Jedes Jahrespreisniveau bildet die Basis fuer das naechste. Zehn Jahre mit 3 % sind daher nicht einfach 30 %. Der Faktor ist 1,03 hoch zehn, also ungefaehr 1,344. Kleine Ratenunterschiede werden ueber lange Zeitraeume sichtbar.</p>' },
+  { type: 'list' as const, items: ['Vergleiche niedrige, mittlere und hohe Raten.', 'Nutze die Meilensteintabelle fuer wichtige Ausgaben.', 'Vergleiche den Kostenwert mit Sparziel, Einkommen oder Rente.', 'Notiere Annahme und Datum und ersetze sie bei neuen Erkenntnissen.'] },
+  { type: 'title' as const, text: 'Einzahlungen und Entnahmen', level: 3 },
+  { type: 'paragraph' as const, html: '<p>Eine Einzahlung wird am Jahresende zum Nominalguthaben addiert. Eine Entnahme wird dort abgezogen; wenn sie das Guthaben aufbraucht, bleibt es bei null. So bleibt der Inflationseffekt sichtbar.</p>' },
+  { type: 'paragraph' as const, html: '<p>Die gestrichelte Guthabenlinie wird mit demselben Faktor in heutiges Geld umgerechnet. Sie ist keine Anlageprojektion und enthält weder Zinsen noch Markttrend, Steuer, Gebuehr oder Wachstum der Einzahlung.</p>' },
+  { type: 'tip' as const, title: 'Nutze eine Bandbreite statt eines Versprechens', html: '<p>Ein Verbraucherpreisindex beschreibt einen Durchschnittswarenkorb. Deine Miete, Energie, Lebensmittel und Gesundheit koennen sich anders entwickeln. Teste mehrere Raten.</p>' },
+  { type: 'title' as const, text: 'Was der Zeitverlauf nicht sagt', level: 3 },
+  { type: 'paragraph' as const, html: '<p>Das Tool ruft keine historischen CPI-Daten ab, prognostiziert keine Inflation und empfiehlt keine Anlage. Veraenderliche Jahresraten, Renditen, Kreditzinsen und unregelmaessige Cashflows sind nicht modelliert.</p>' },
+  { type: 'paragraph' as const, html: '<p>Bei wichtigen Entscheidungen vergleiche das Ergebnis mit einem passenden Verbraucherpreisindex, deinen Ausgabenaufzeichnungen und den Vertragsbedingungen. Ein mathematisch konsistentes Ergebnis muss deinen Haushalt nicht genau beschreiben.</p>' },
+];
+export const content: ToolLocaleContent<InflationPurchasingPowerUI> = { slug: 'inflation-kaufkraft-zeitstrahl-rechner', title, description, ui, faq, bibliography, howTo, schemas: [faqSchema, howToSchema, appSchema], seo };

package/src/tool/inflationPurchasingPower/i18n/en.ts

@@ -0,0 +1,131 @@
+import { bibliography } from '../bibliography';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { InflationPurchasingPowerUI } from '../ui';
+
+const slug = 'inflation-purchasing-power-timeline-calculator';
+const title = 'Inflation Purchasing Power Timeline Calculator';
+const description = 'See how an annual inflation assumption changes the amount needed to preserve purchasing power and the real value of cash over time.';
+
+const ui: InflationPurchasingPowerUI = {
+  amountLabel: 'Starting amount',
+  amountHelp: 'Use any currency and keep it consistent',
+  inflationLabel: 'Annual inflation rate (%)',
+  inflationHelp: 'A scenario assumption, not a forecast',
+  yearsLabel: 'Time horizon (years)',
+  yearsHelp: 'Choose from 1 to 80 years',
+  cashFlowLabel: 'Annual cash flow',
+  cashFlowHelp: 'Added to or taken from the balance each year',
+  cashFlowModeLabel: 'Cash flow scenario',
+  noCashFlowOption: 'No recurring flow',
+  contributionOption: 'Add each year',
+  withdrawalOption: 'Withdraw each year',
+  costEquivalentLabel: 'End cost equivalent',
+  realValueLabel: 'End value in today\'s money',
+  nominalBalanceLabel: 'End nominal balance',
+  purchasingPowerLossLabel: 'Purchasing power lost',
+  todayLabel: 'Today',
+  endLabel: 'End of horizon',
+  costLineLabel: 'Cost to preserve the same basket',
+  realLineLabel: 'Unchanged cash buying power',
+  balanceLineLabel: 'Scenario balance in today\'s money',
+  chartDescription: 'Inflation timeline showing the rising cost equivalent, falling buying power and scenario balance',
+  chartNote: 'Each line is measured against the starting amount',
+  milestoneTitle: 'Milestones in the same currency',
+  yearHeader: 'Year',
+  costHeader: 'Cost equivalent',
+  realHeader: 'Unchanged cash',
+  balanceHeader: 'Real balance',
+  methodTitle: 'How the timeline works',
+  methodText: 'The cost equivalent is the starting amount multiplied by (1 + annual inflation rate) to the power of the number of years. The value of unchanged cash is the starting amount divided by that same factor. A contribution is added at the end of each year and a withdrawal is subtracted at the end of each year, with the balance stopping at zero.',
+  limitationText: 'This is a transparent scenario model, not a historical CPI lookup, investment return forecast or personal financial advice. Your household basket can differ from a published consumer price index, and actual inflation can change from year to year.',
+  emptyMessage: 'Enter a positive amount, a rate above -100%, a whole number of years from 1 to 80 and a non-negative cash flow.',
+  contributionSummary: 'The dashed line shows the value today of the balance after the recurring contributions, with no investment return included.',
+  withdrawalSummary: 'The dashed line shows the value today of the balance after the recurring withdrawals, with no investment return included.',
+  noCashFlowSummary: 'The solid lines isolate inflation itself: one shows the future cost of the same basket and the other shows what unchanged cash can buy.',
+  depletionWarning: 'The withdrawal scenario reaches zero in year {year}; later years remain at zero.',
+  scenarioNote: 'Scenario only',
+  currencyHint: 'Same currency as the starting amount',
+  yearsSuffix: 'years',
+  amountSuffix: 'in the same currency as your starting amount',
+};
+
+const faq = [
+  {
+    question: 'How does inflation reduce purchasing power?',
+    answer: 'When the general price level rises, the same amount buys fewer goods and services. This calculator models that effect by dividing unchanged cash by the compounded inflation factor.',
+  },
+  {
+    question: 'What is the difference between cost equivalent and real value?',
+    answer: 'Cost equivalent is the future amount needed to buy what the starting amount buys today. Real value is what the unchanged starting amount can buy at the end of the selected horizon, expressed in today\'s money.',
+  },
+  {
+    question: 'What do the contribution and withdrawal scenarios include?',
+    answer: 'They add or subtract the cash flow at the end of each year. They do not include investment returns, taxes, fees or interest, and a withdrawal balance cannot fall below zero.',
+  },
+  {
+    question: 'Is the inflation rate a prediction?',
+    answer: 'No. It is an assumption for exploring sensitivity. Actual inflation can vary, and a published consumer price index may not match the spending pattern of your household.',
+  },
+];
+
+const howTo = [
+  { name: 'Enter a starting amount', text: 'Use the amount whose future purchasing power you want to inspect, keeping one currency throughout the calculation.' },
+  { name: 'Set an inflation scenario', text: 'Enter an annual rate and a whole-number time horizon. Use a range of rates when you want to test sensitivity instead of relying on one assumption.' },
+  { name: 'Add an optional cash flow', text: 'Choose Add each year or Withdraw each year, then enter the recurring amount. Leave No recurring flow selected to isolate inflation.' },
+  { name: 'Read the curves and milestones', text: 'Compare the end cost equivalent with the end value in today\'s money, then use the milestone table to see when the gap becomes material.' },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.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: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'FinanceApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<InflationPurchasingPowerUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Use an inflation timeline to plan for a changing price level', level: 2 },
+    { type: 'paragraph', html: '<p>Inflation changes the price level over time, so a cash amount that looks unchanged can buy less in the future. This calculator separates two questions that are often mixed together: how much money may be needed to buy the same basket, and how much purchasing power unchanged cash retains.</p>' },
+    { type: 'paragraph', html: '<p>Enter a starting amount, an annual inflation assumption and a time horizon. The timeline compounds the rate each year, then shows the cost equivalent rising while the buying power of unchanged cash falls. The result is expressed in the same currency as your input and does not pretend to know the future path of prices.</p>' },
+    { type: 'title', text: 'The two core readings', level: 3 },
+    { type: 'table', headers: ['Reading', 'Formula', 'Use it to answer'], rows: [['Cost equivalent', 'Starting amount x (1 + inflation rate)^years', 'How much would be needed at the end to buy the same basket?'], ['Unchanged cash buying power', 'Starting amount / (1 + inflation rate)^years', 'What can the original cash buy at the end, measured in today\'s money?'], ['Purchasing power lost', '(1 - 1 / price factor) x 100', 'What share of the starting buying power is no longer available?']] },
+    { type: 'paragraph', html: '<p>For example, at 3% annual inflation, 1,000 becomes a cost equivalent of about 1,344 after ten years. If the 1,000 stays unchanged in cash, its purchasing power is about 744 in today\'s money. Those are two views of the same price-level change, not two separate investment returns.</p>' },
+    { type: 'title', text: 'Why compounding matters', level: 3 },
+    { type: 'paragraph', html: '<p>Annual inflation rates compound because each year\'s prices become the base for the next year. Ten years at 3% is not a flat 30% adjustment: the factor is 1.03 to the tenth power, or about 1.344. Small differences in the assumed rate become more visible over longer horizons.</p>' },
+    { type: 'list', items: ['Run a low, central and high rate instead of trusting one scenario.', 'Use the milestone table to identify when a planned expense becomes materially more expensive.', 'Compare the cost equivalent with an income, pension or savings target expressed in the same currency.', 'Treat the result as a planning reference and replace the assumption when your evidence changes.'] },
+    { type: 'title', text: 'Adding contributions or withdrawals', level: 3 },
+    { type: 'paragraph', html: '<p>The optional cash-flow scenario makes the timeline more useful for a savings or spending plan without hiding the inflation effect. A contribution is added to the nominal balance at the end of each year. A withdrawal is subtracted at the same point, and the model stops the balance at zero when the withdrawals exhaust it.</p>' },
+    { type: 'paragraph', html: '<p>The dashed balance line is converted back into today\'s money using the same inflation factor. It is not an investment projection: no interest, market return, tax, fee or contribution growth is included. If you need to plan a real portfolio, keep the inflation assumption and the return assumption as separate scenarios.</p>' },
+    { type: 'tip', title: 'Use the rate as a range, not a promise', html: '<p>Published consumer price indexes describe an average basket, while your own rent, energy, food, travel and healthcare mix may move differently. Test several rates and label the result with the assumption and date you used.</p>' },
+    { type: 'title', text: 'What the timeline cannot tell you', level: 3 },
+    { type: 'paragraph', html: '<p>This tool does not retrieve historical CPI data, forecast inflation, estimate a personal cost of living, calculate taxes or recommend an investment. It also does not model changing annual rates, asset returns, debt interest or irregular cash flows. Its value is making one assumption visible and showing how strongly the horizon changes the result.</p>' },
+    { type: 'paragraph', html: '<p>For an important decision, compare the output with an appropriate official price index, your actual spending records and the terms of the product or income you are planning around. A result can be mathematically consistent and still be a poor description of your household or country.</p>' },
+  ],
+};