@jjlmoya/utils-finance 1.44.0 → 1.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-finance",
-    "version": "1.44.0",
+    "version": "1.46.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -36,7 +36,7 @@
         "postinstall": "node scripts/postinstall.mjs",
         "predev": "node scripts/postinstall.mjs",
         "prestart": "node scripts/postinstall.mjs",
-        "prebuild": "node scripts/postinstall.mjs",
+        "prebuild": "node scripts/postinstall.mjs && node scripts/validate-icons.mjs",
         "qa": "npm run lint && npm run test && npm run build",
         "cf:dry-run": "npm run build && wrangler deploy --dry-run",
         "cf:preview": "npm run build && wrangler deploy --config wrangler.staging.jsonc",

package/scripts/validate-icons.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'node:module';
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const packageJsonPath = require.resolve('@iconify-json/mdi/package.json');
+const packageRoot = dirname(packageJsonPath);
+const iconSet = JSON.parse(readFileSync(join(packageRoot, 'icons.json'), 'utf8'));
+const availableIcons = new Set([
+  ...Object.keys(iconSet.icons ?? {}),
+  ...Object.keys(iconSet.aliases ?? {}),
+]);
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const sourceRoot = resolve(repoRoot, 'src');
+const extensions = new Set(['.astro', '.js', '.mjs', '.ts', '.tsx']);
+const iconPattern = /\bmdi:([a-z0-9-]+)\b/g;
+const failures = [];
+let references = 0;
+
+function walk(directory) {
+  const entries = readdirSync(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== 'node_modules' && entry.name !== 'dist' && entry.name !== 'tests') {
+        walk(path);
+      }
+      continue;
+    }
+    if (!extensions.has(path.slice(path.lastIndexOf('.')))) continue;
+
+    const source = readFileSync(path, 'utf8');
+    for (const match of source.matchAll(iconPattern)) {
+      references += 1;
+      const iconName = match[1];
+      if (availableIcons.has(iconName)) continue;
+
+      const line = source.slice(0, match.index).split('\n').length;
+      failures.push(`${relative(repoRoot, path)}:${line} — mdi:${iconName}`);
+    }
+  }
+}
+
+walk(sourceRoot);
+
+if (failures.length > 0) {
+  console.error('Invalid MDI icons found:');
+  for (const failure of failures) console.error(`- ${failure}`);
+  console.error(`Checked ${references} MDI icon references against @iconify-json/mdi.`);
+  process.exitCode = 1;
+} else {
+  console.log(`MDI icon validation passed: ${references} references checked.`);
+}

package/src/entries.ts

@@ -76,4 +76,5 @@ import { loanToIncomeRatio } from './tool/loanToIncomeRatio/entry';
 import { rentalDepositReturn } from './tool/rentalDepositReturn/entry';
 import { capitalGainsTaxScenarioCalculator } from './tool/capitalGainsTaxScenarioCalculator/entry';
 import { insuranceDeductibleBreakEvenCalculator } from './tool/insuranceDeductibleBreakEvenCalculator/entry';
-export const ALL_ENTRIES = [compoundInterest, financialFreedom, savingsRate, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator, pesetaValue, salaryEmployerCost, dividendYield, mortgageExtraPaymentPlanner, inflationPurchasingPower, subscriptionCostAnnualizer, loanToIncomeRatio, rentalDepositReturn, capitalGainsTaxScenarioCalculator, insuranceDeductibleBreakEvenCalculator];
+import { renterInsuranceCoverageGapCalculator } from './tool/renterInsuranceCoverageGapCalculator/entry';
+export const ALL_ENTRIES = [compoundInterest, financialFreedom, savingsRate, profitability, courtFeeCalculator, debtSnowball, fireCalculator, ibanBicSwift, inflation, lateInterest, legalInterestRate, lotteryOptimizer, mortgage, percentageCalculator, rentIncrease, revolvingCardCalculator, pesetaValue, salaryEmployerCost, dividendYield, mortgageExtraPaymentPlanner, inflationPurchasingPower, subscriptionCostAnnualizer, loanToIncomeRatio, rentalDepositReturn, capitalGainsTaxScenarioCalculator, insuranceDeductibleBreakEvenCalculator, renterInsuranceCoverageGapCalculator];

package/src/tests/locale_completeness.test.ts

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

package/src/tests/mfe_assets_contract.test.ts

@@ -0,0 +1,48 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { CATEGORY_OG_IMAGE, getUtilityOgImage } from '../mfe/assets';
+
+const categoryImageMatch = CATEGORY_OG_IMAGE.match(
+  /^(\/_utilities\/[^/]+\/images)\/([^/]+\.webp)\?version=(.+)$/,
+);
+
+if (!categoryImageMatch) {
+  throw new Error(`Unexpected CATEGORY_OG_IMAGE format: ${CATEGORY_OG_IMAGE}`);
+}
+
+const [, imageUrlRoot, categoryImage, assetVersion] = categoryImageMatch;
+const assetRoot = join(process.cwd(), 'public', imageUrlRoot.slice(1));
+const categorySlug = basename(categoryImage, '.webp');
+
+describe('MFE asset contract', () => {
+  it('has one non-empty English-slug OG image per category and registered tool', async () => {
+    const expectedSlugs = new Set([categorySlug]);
+
+    for (const { entry } of ALL_TOOLS) {
+      const englishLoader = entry.i18n.en;
+      if (!englishLoader) throw new Error(`Missing English locale for ${entry.id}`);
+
+      const englishContent = await englishLoader();
+      expectedSlugs.add(englishContent.slug);
+    }
+
+    const actualSlugs = new Set(
+      readdirSync(assetRoot)
+        .filter((filename) => filename.endsWith('.webp'))
+        .map((filename) => filename.slice(0, -'.webp'.length)),
+    );
+
+    expect(actualSlugs).toEqual(expectedSlugs);
+
+    for (const slug of expectedSlugs) {
+      const imagePath = join(assetRoot, `${slug}.webp`);
+      expect(existsSync(imagePath), `${imagePath} should exist`).toBe(true);
+      expect(statSync(imagePath).size, `${imagePath} should not be empty`).toBeGreaterThan(0);
+      expect(getUtilityOgImage(slug)).toBe(
+        `${imageUrlRoot}/${slug}.webp?version=${assetVersion}`,
+      );
+    }
+  }, 30000);
+});

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

package/src/tool/renterInsuranceCoverageGapCalculator/bibliography.astro

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

package/src/tool/renterInsuranceCoverageGapCalculator/bibliography.ts

@@ -0,0 +1,6 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  { name: 'Financial Ombudsman Service: Underinsurance in home insurance complaints', url: 'https://www.financial-ombudsman.org.uk/consumers/complaints-can-help/insurance/home-insurance/underinsurance' },
+  { name: 'BOE: Ley 50/1980, de 8 de octubre, de Contrato de Seguro', url: 'https://www.boe.es/buscar/pdf/1980/BOE-A-1980-22501-consolidado.pdf' },
+];

package/src/tool/renterInsuranceCoverageGapCalculator/component.astro

@@ -0,0 +1,80 @@
+---
+import type { KnownLocale } from '../../types';
+import { INVENTORY_CATEGORIES, type RenterInsuranceInput } from './logic';
+import { currencyOptions, defaultCurrencyByLocale } from './currency';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+interface Props { locale?: KnownLocale; ui?: RenterInsuranceCoverageGapCalculatorUI; }
+const { ui } = Astro.props;
+const t = ui as RenterInsuranceCoverageGapCalculatorUI;
+const locale = Astro.props.locale ?? 'en';
+const defaultCurrency = defaultCurrencyByLocale[locale] ?? 'USD';
+const defaultSymbol = currencyOptions.find(({ code }) => code === defaultCurrency)?.symbol ?? defaultCurrency;
+const initial: RenterInsuranceInput = {
+  currency: defaultCurrency,
+  policyLimit: 18000,
+  deductible: 250,
+  sampleLoss: 5000,
+  inventory: [
+    { category: 'furniture', value: 7000 },
+    { category: 'electronics', value: 6000 },
+    { category: 'clothing', value: 2500 },
+    { category: 'kitchen', value: 1500 },
+    { category: 'personal', value: 1000 },
+    { category: 'other', value: 1000 },
+  ],
+};
+const config = JSON.stringify({ ui: t, initial, locale, currencies: currencyOptions }).replace(/</g, '\\u003c');
+const categoryLabels: Record<(typeof INVENTORY_CATEGORIES)[number], string> = {
+  furniture: t.labelCategoryFurniture,
+  electronics: t.labelCategoryElectronics,
+  clothing: t.labelCategoryClothing,
+  kitchen: t.labelCategoryKitchen,
+  personal: t.labelCategoryPersonal,
+  other: t.labelCategoryOther,
+};
+---
+
+<div class="ric-tool" data-ric-tool>
+  <form class="ric-card" data-ric-form novalidate>
+    <div class="ric-workspace">
+      <section class="ric-inventory-panel" aria-labelledby="ric-inventory-title">
+        <div class="ric-panel-heading"><span class="ric-eyebrow">01 / {t.labelInventory}</span><h2 id="ric-inventory-title">{t.labelInventory}</h2><p>{t.labelInventoryHint}</p></div>
+        <div class="ric-shelf-scene" data-ric-visual role="img" aria-label={t.labelCoverageLine}>
+          <div class="ric-shelf-top"><span>{t.labelReplacementValue}</span><span data-ric-loss-label>{t.labelLossScenario}</span></div>
+          <div class="ric-shelf-track"><span class="ric-contents-fill" data-ric-contents-fill></span><span class="ric-limit-line" data-ric-limit-line aria-label={t.labelLimitMarker}></span><span class="ric-loss-mark" data-ric-loss-mark aria-hidden="true"></span></div>
+          <div class="ric-shelf-legend"><span><i class="ric-dot ric-dot-contents"></i>{t.labelReplacementValue}</span><span><i class="ric-dot ric-dot-limit"></i>{t.labelCoverageLine}</span></div>
+        </div>
+        <div class="ric-inventory-list">
+          {INVENTORY_CATEGORIES.map((category) => <label class="ric-inventory-row" for={`ric-${category}`}><span>{categoryLabels[category]}</span><span class="ric-money-input"><input id={`ric-${category}`} data-category={category} type="number" min="0" max="1000000000" step="0.01" value={initial.inventory.find((item) => item.category === category)?.value ?? 0} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></span></label>)}
+        </div>
+        <ol class="ric-largest-list" data-ric-largest-list aria-label={t.labelLargestCategories}></ol>
+      </section>
+
+      <section class="ric-policy-panel" aria-labelledby="ric-policy-title">
+        <div class="ric-panel-heading"><span class="ric-eyebrow">02 / {t.labelPolicyBoundary}</span><h2 id="ric-policy-title">{t.labelSetLimit}</h2><p>{t.labelPolicyBoundaryHint}</p></div>
+        <div class="ric-field-stack">
+          <div class="ric-field ric-currency-field"><span class="ric-label" id="ric-currency-label">{t.labelCurrency}</span><div class="ric-select"><button type="button" class="ric-select-trigger" data-ric-currency-trigger aria-expanded="false" aria-haspopup="listbox" aria-labelledby="ric-currency-label"><span class="ric-currency-trigger-main"><strong data-ric-selected-symbol>{defaultSymbol}</strong><span data-ric-selected-code>{defaultCurrency}</span></span><span class="ric-currency-arrow" aria-hidden="true"></span></button><div class="ric-select-menu" data-ric-currency-menu role="listbox" aria-label={t.labelCurrency} hidden>{currencyOptions.map(({ code, symbol, name }) => <button type="button" class="ric-currency-option" data-ric-currency-option data-currency={code} role="option" aria-selected={code === defaultCurrency} aria-label={`${symbol} ${name}`}><strong>{symbol}</strong><span>{code}</span><small>{name}</small></button>)}</div></div><small>{t.labelApproximateRates}</small></div>
+          <div class="ric-field"><label for="ric-policy-limit">{t.labelPolicyLimit}</label><div class="ric-money-input"><input id="ric-policy-limit" data-field="policyLimit" type="number" min="0.01" max="1000000000" step="0.01" value={initial.policyLimit} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelPolicyLimitHelp}</small></div>
+          <div class="ric-field"><label for="ric-deductible">{t.labelDeductible}</label><div class="ric-money-input"><input id="ric-deductible" data-field="deductible" type="number" min="0" max="1000000000" step="0.01" value={initial.deductible} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelDeductibleHelp}</small></div>
+          <div class="ric-field"><label for="ric-sample-loss">{t.labelSampleLoss}</label><div class="ric-money-input"><input id="ric-sample-loss" data-field="sampleLoss" type="number" min="0.01" max="1000000000" step="0.01" value={initial.sampleLoss} placeholder={t.labelAmountPlaceholder} inputmode="decimal" required /><b data-ric-unit>{defaultSymbol}</b></div><small>{t.labelSampleLossHelp}</small></div>
+        </div>
+        <div class="ric-result-block" aria-live="polite" aria-atomic="true"><span class="ric-eyebrow">03 / {t.labelStatus}</span><strong class="ric-status" data-ric-status>{t.labelStatusReview}</strong><p data-ric-status-text></p><p class="ric-error" data-ric-error hidden>{t.labelInvalidInput}</p><div class="ric-metric-main"><span>{t.labelCoverageGap}</span><strong data-ric-gap>—</strong></div><div class="ric-metric-line"><span>{t.labelTotalContents}</span><b data-ric-total>—</b></div><div class="ric-metric-line"><span>{t.labelCoverageRatio}</span><b data-ric-ratio>—</b></div><div class="ric-metric-line"><span>{t.labelEstimatedPayout}</span><b data-ric-payout>—</b></div><div class="ric-metric-line"><span>{t.labelOutOfPocket}</span><b data-ric-out-of-pocket>—</b></div><p class="ric-result-note">{t.labelIllustrativePayout}</p></div>
+        <div class="ric-actions"><button type="button" class="ric-button ric-button-secondary" data-ric-reset>{t.labelReset}</button><button type="button" class="ric-button ric-button-primary" data-ric-copy>{t.labelCopy}</button><span data-ric-copy-status role="status" aria-live="polite"></span></div>
+      </section>
+    </div>
+    <p class="ric-privacy">{t.labelPrivacyNote}</p><details class="ric-method"><summary>{t.labelMethodTitle}</summary><p>{t.labelMethodText}</p></details>
+  </form>
+</div>
+
+<script is:inline type="application/json" data-ric-config set:html={config}></script>
+<script>
+  import { mountRenterInsuranceTool } from './controller';
+  const configElement = document.querySelector<HTMLScriptElement>('[data-ric-config]');
+  const root = document.querySelector<HTMLElement>('[data-ric-tool]');
+  if (root && configElement?.textContent) mountRenterInsuranceTool(root, JSON.parse(configElement.textContent));
+</script>
+
+<style>
+  @import './renter-insurance-coverage-gap-calculator.css';
+</style>

package/src/tool/renterInsuranceCoverageGapCalculator/controller.ts

@@ -0,0 +1,102 @@
+import { calculateRenterInsuranceCoverageGap, validateRenterInsuranceInput, type RenterInsuranceInput } from './logic';
+import { convertRenterInsuranceCurrency, isRenterInsuranceCurrencyCode, type RenterInsuranceCurrencyCode } from './currency';
+import { clearRenterInsuranceResult, formatMoney, renderRenterInsuranceResult, type ViewConfig } from './dom-views';
+import { readSavedRenterInsuranceInput, saveRenterInsuranceInput } from './storage';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+interface ControllerConfig {
+  initial: RenterInsuranceInput;
+  locale: string;
+  ui: RenterInsuranceCoverageGapCalculatorUI;
+}
+
+const getNumber = (form: HTMLFormElement, field: string): number => Number(form.querySelector<HTMLInputElement>(`[data-field="${field}"]`)?.value ?? Number.NaN);
+
+const readInput = (form: HTMLFormElement, currency: string): RenterInsuranceInput => ({
+  currency,
+  policyLimit: getNumber(form, 'policyLimit'),
+  deductible: getNumber(form, 'deductible'),
+  sampleLoss: getNumber(form, 'sampleLoss'),
+  inventory: Array.from(form.querySelectorAll<HTMLInputElement>('[data-category]')).map((input) => ({ category: input.dataset.category as RenterInsuranceInput['inventory'][number]['category'], value: Number(input.value) })),
+});
+
+const setFieldValues = (form: HTMLFormElement, input: RenterInsuranceInput): void => {
+  ['policyLimit', 'deductible', 'sampleLoss'].forEach((field) => {
+    const element = form.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+    if (element) element.value = String(input[field as 'policyLimit' | 'deductible' | 'sampleLoss']);
+  });
+  input.inventory.forEach((item) => {
+    const element = form.querySelector<HTMLInputElement>(`[data-category="${item.category}"]`);
+    if (element) element.value = String(item.value);
+  });
+};
+
+const updateFieldErrors = (root: HTMLElement, form: HTMLFormElement, input: RenterInsuranceInput): boolean => {
+  const errors = validateRenterInsuranceInput(input);
+  form.querySelectorAll<HTMLInputElement>('[data-field], [data-category]').forEach((field) => field.setAttribute('aria-invalid', 'false'));
+  Object.keys(errors).forEach((key) => form.querySelector<HTMLInputElement>(`[data-field="${key}"]`)?.setAttribute('aria-invalid', 'true'));
+  const summary = root.querySelector<HTMLElement>('[data-ric-error]');
+  if (summary) summary.hidden = Object.keys(errors).length === 0;
+  if (errors.inventory) form.querySelectorAll<HTMLInputElement>('[data-category]').forEach((field) => field.setAttribute('aria-invalid', 'true'));
+  return Object.keys(errors).length > 0;
+};
+
+const setCurrency = (root: HTMLElement, currency: RenterInsuranceCurrencyCode): void => {
+  const selectedOption = root.querySelector<HTMLButtonElement>(`[data-ric-currency-option][data-currency="${currency}"]`);
+  const symbol = selectedOption?.querySelector('strong')?.textContent ?? currency;
+  root.querySelectorAll<HTMLElement>('[data-ric-unit]').forEach((unit) => { unit.textContent = symbol; });
+  root.querySelectorAll<HTMLButtonElement>('[data-ric-currency-option]').forEach((option) => option.setAttribute('aria-selected', String(option.dataset.currency === currency)));
+  const selectedCode = root.querySelector<HTMLElement>('[data-ric-selected-code]');
+  if (selectedCode) selectedCode.textContent = currency;
+  const selectedSymbol = root.querySelector<HTMLElement>('[data-ric-selected-symbol]');
+  if (selectedSymbol) selectedSymbol.textContent = symbol;
+};
+
+const mountCurrencyMenu = (root: HTMLElement, onSelect: (currency: RenterInsuranceCurrencyCode) => void): void => {
+  const trigger = root.querySelector<HTMLButtonElement>('[data-ric-currency-trigger]');
+  const menu = root.querySelector<HTMLElement>('[data-ric-currency-menu]');
+  const close = (): void => { if (menu && trigger) { menu.hidden = true; trigger.setAttribute('aria-expanded', 'false'); } };
+  trigger?.addEventListener('click', () => { if (menu) { menu.hidden = !menu.hidden; trigger.setAttribute('aria-expanded', String(!menu.hidden)); } });
+  root.querySelectorAll<HTMLButtonElement>('[data-ric-currency-option]').forEach((option) => option.addEventListener('click', () => { const nextCurrency = option.dataset.currency; if (nextCurrency && isRenterInsuranceCurrencyCode(nextCurrency)) onSelect(nextCurrency); close(); }));
+  document.addEventListener('click', (event) => { if (!root.contains(event.target as Node)) close(); });
+};
+
+const mountCopyAction = (root: HTMLElement, form: HTMLFormElement, config: ControllerConfig, getCurrency: () => RenterInsuranceCurrencyCode): void => {
+  form.querySelector('[data-ric-copy]')?.addEventListener('click', () => {
+    const result = calculateRenterInsuranceCoverageGap(readInput(form, getCurrency()));
+    if (!result) return;
+    const summary = `${config.ui.labelCoverageGap}: ${formatMoney(config.locale, result.currency, result.coverageGap)}. ${config.ui.labelCoverageRatio}: ${Math.round(result.coverageRatio * 100)}%. ${config.ui.labelLargestCategories}: ${result.largestCategories.map((item) => item.category).join(', ')}.`;
+    navigator.clipboard?.writeText(summary).then(() => { const status = root.querySelector<HTMLElement>('[data-ric-copy-status]'); if (status) status.textContent = config.ui.labelCopied; }).catch(() => { const status = root.querySelector<HTMLElement>('[data-ric-copy-status]'); if (status) status.textContent = config.ui.labelCopyFailed; });
+  });
+};
+
+export function mountRenterInsuranceTool(root: HTMLElement, config: ControllerConfig): void {
+  const form = root.querySelector<HTMLFormElement>('[data-ric-form]');
+  if (!form) return;
+  const saved = readSavedRenterInsuranceInput(config.initial);
+  let currency: RenterInsuranceCurrencyCode = isRenterInsuranceCurrencyCode(saved.currency) ? saved.currency : config.initial.currency as RenterInsuranceCurrencyCode;
+  setFieldValues(form, saved);
+  const viewConfig: ViewConfig = { root, locale: config.locale, ui: config.ui };
+  const update = (): void => {
+    const input = readInput(form, currency);
+    if (updateFieldErrors(root, form, input)) { clearRenterInsuranceResult(root, config.ui); return; }
+    const result = calculateRenterInsuranceCoverageGap(input);
+    if (!result) return;
+    saveRenterInsuranceInput(input);
+    renderRenterInsuranceResult(viewConfig, result);
+  };
+  const reset = (): void => { currency = config.initial.currency as RenterInsuranceCurrencyCode; setFieldValues(form, config.initial); setCurrency(root, currency); update(); };
+  form.querySelectorAll<HTMLInputElement>('[data-field], [data-category]').forEach((field) => field.addEventListener('input', update));
+  form.querySelector('[data-ric-reset]')?.addEventListener('click', reset);
+  mountCopyAction(root, form, config, () => currency);
+  mountCurrencyMenu(root, (nextCurrency) => {
+    if (nextCurrency === currency) return;
+    const moneyFields = [...Array.from(form.querySelectorAll<HTMLInputElement>('[data-field]')), ...Array.from(form.querySelectorAll<HTMLInputElement>('[data-category]'))];
+    moneyFields.forEach((field) => { const value = Number(field.value); if (Number.isFinite(value)) field.value = String(convertRenterInsuranceCurrency(value, currency, nextCurrency)); });
+    currency = nextCurrency;
+    setCurrency(root, currency);
+    update();
+  });
+  setCurrency(root, currency);
+  update();
+}

package/src/tool/renterInsuranceCoverageGapCalculator/currency.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { convertRenterInsuranceCurrency, currencyOptions, defaultCurrencyByLocale } from './currency';
+
+describe('renter insurance currency support', () => {
+  it('offers the international currency set used by insurance tools', () => {
+    expect(currencyOptions.map(({ code }) => code)).toEqual(['AUD', 'BRL', 'CAD', 'CHF', 'CNY', 'CZK', 'DKK', 'EUR', 'GBP', 'IDR', 'INR', 'JPY', 'KRW', 'MXN', 'NOK', 'PLN', 'RUB', 'SEK', 'TRY', 'USD']);
+  });
+
+  it('selects a useful default for each supported locale family', () => {
+    expect(defaultCurrencyByLocale).toMatchObject({ en: 'USD', es: 'EUR', ja: 'JPY', zh: 'CNY' });
+  });
+
+  it('converts monetary inputs with reversible planning factors', () => {
+    expect(convertRenterInsuranceCurrency(100, 'EUR', 'USD')).toBe(108.7);
+    expect(convertRenterInsuranceCurrency(108.7, 'USD', 'EUR')).toBe(100);
+  });
+});

package/src/tool/renterInsuranceCoverageGapCalculator/currency.ts

@@ -0,0 +1,69 @@
+export const currencyOptions = [
+  { code: 'AUD', symbol: 'A$', name: 'Australian dollar' },
+  { code: 'BRL', symbol: 'R$', name: 'Brazilian real' },
+  { code: 'CAD', symbol: 'C$', name: 'Canadian dollar' },
+  { code: 'CHF', symbol: 'CHF', name: 'Swiss franc' },
+  { code: 'CNY', symbol: '¥', name: 'Chinese yuan' },
+  { code: 'CZK', symbol: 'Kč', name: 'Czech koruna' },
+  { code: 'DKK', symbol: 'kr', name: 'Danish krone' },
+  { code: 'EUR', symbol: '€', name: 'Euro' },
+  { code: 'GBP', symbol: '£', name: 'British pound' },
+  { code: 'IDR', symbol: 'Rp', name: 'Indonesian rupiah' },
+  { code: 'INR', symbol: '₹', name: 'Indian rupee' },
+  { code: 'JPY', symbol: '¥', name: 'Japanese yen' },
+  { code: 'KRW', symbol: '₩', name: 'South Korean won' },
+  { code: 'MXN', symbol: 'MX$', name: 'Mexican peso' },
+  { code: 'NOK', symbol: 'kr', name: 'Norwegian krone' },
+  { code: 'PLN', symbol: 'zł', name: 'Polish złoty' },
+  { code: 'RUB', symbol: '₽', name: 'Russian ruble' },
+  { code: 'SEK', symbol: 'kr', name: 'Swedish krona' },
+  { code: 'TRY', symbol: '₺', name: 'Turkish lira' },
+  { code: 'USD', symbol: '$', name: 'US dollar' },
+] as const;
+
+export type RenterInsuranceCurrencyCode = (typeof currencyOptions)[number]['code'];
+
+export const defaultCurrencyByLocale: Record<string, RenterInsuranceCurrencyCode> = {
+  de: 'EUR',
+  en: 'USD',
+  es: 'EUR',
+  fr: 'EUR',
+  id: 'IDR',
+  it: 'EUR',
+  ja: 'JPY',
+  ko: 'KRW',
+  nl: 'EUR',
+  pl: 'PLN',
+  pt: 'EUR',
+  ru: 'RUB',
+  sv: 'SEK',
+  tr: 'TRY',
+  zh: 'CNY',
+};
+
+const approximateUsdFactors: Record<RenterInsuranceCurrencyCode, number> = {
+  AUD: 1.52,
+  BRL: 5.1,
+  CAD: 1.38,
+  CHF: 0.88,
+  CNY: 7.2,
+  CZK: 23,
+  DKK: 6.85,
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  IDR: 16000,
+  INR: 84,
+  JPY: 150,
+  KRW: 1380,
+  MXN: 18,
+  NOK: 10.7,
+  PLN: 3.95,
+  RUB: 90,
+  SEK: 10.5,
+  TRY: 34,
+};
+
+export const isRenterInsuranceCurrencyCode = (value: string): value is RenterInsuranceCurrencyCode => currencyOptions.some(({ code }) => code === value);
+
+export const convertRenterInsuranceCurrency = (amount: number, from: RenterInsuranceCurrencyCode, to: RenterInsuranceCurrencyCode): number => Number((amount * approximateUsdFactors[to] / approximateUsdFactors[from]).toFixed(2));

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

@@ -0,0 +1,68 @@
+import type { CoverageCategoryResult, RenterInsuranceResult } from './logic';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+import { evaluateCoverage } from './evaluator';
+
+export interface ViewConfig {
+  root: HTMLElement;
+  locale: string;
+  ui: RenterInsuranceCoverageGapCalculatorUI;
+}
+
+const setText = (root: HTMLElement, selector: string, value: string): void => {
+  const element = root.querySelector<HTMLElement>(selector);
+  if (element) element.textContent = value;
+};
+
+const formatMoney = (locale: string, currency: string, value: number): string => new Intl.NumberFormat(locale, {
+  style: 'currency',
+  currency,
+  maximumFractionDigits: 2,
+}).format(value);
+
+const renderCategoryList = (root: HTMLElement, categories: CoverageCategoryResult[], locale: string, currency: string): void => {
+  const list = root.querySelector<HTMLOListElement>('[data-ric-largest-list]');
+  if (!list) return;
+  list.replaceChildren(...categories.map((category) => {
+    const item = document.createElement('li');
+    item.textContent = `${category.category}: ${formatMoney(locale, currency, category.value)}`;
+    return item;
+  }));
+};
+
+const renderShelf = (root: HTMLElement, result: RenterInsuranceResult): void => {
+  const total = Math.max(result.totalContents, 1);
+  const contentWidth = Math.min(100, result.totalContents / total * 100);
+  const limitWidth = Math.min(100, result.policyLimit / total * 100);
+  root.querySelector<HTMLElement>('[data-ric-contents-fill]')?.style.setProperty('width', `${contentWidth}%`);
+  root.querySelector<HTMLElement>('[data-ric-limit-line]')?.style.setProperty('left', `${limitWidth}%`);
+  root.querySelector<HTMLElement>('[data-ric-loss-mark]')?.style.setProperty('left', `${Math.min(100, result.sampleLoss / total * 100)}%`);
+};
+
+export function renderRenterInsuranceResult(config: ViewConfig, result: RenterInsuranceResult): void {
+  const { root, locale, ui } = config;
+  const evaluation = evaluateCoverage(result, ui);
+  root.dataset.status = evaluation.status;
+  setText(root, '[data-ric-status]', evaluation.label);
+  setText(root, '[data-ric-status-text]', evaluation.text);
+  setText(root, '[data-ric-total]', formatMoney(locale, result.currency, result.totalContents));
+  setText(root, '[data-ric-gap]', formatMoney(locale, result.currency, result.coverageGap));
+  setText(root, '[data-ric-ratio]', `${new Intl.NumberFormat(locale, { maximumFractionDigits: 1 }).format(result.coverageRatio * 100)}%`);
+  setText(root, '[data-ric-payout]', formatMoney(locale, result.currency, result.estimatedPayout));
+  setText(root, '[data-ric-out-of-pocket]', formatMoney(locale, result.currency, result.estimatedOutOfPocket));
+  setText(root, '[data-ric-loss-label]', `${ui.labelLossScenario}: ${formatMoney(locale, result.currency, result.sampleLoss)}`);
+  renderCategoryList(root, result.largestCategories, locale, result.currency);
+  renderShelf(root, result);
+}
+
+export function clearRenterInsuranceResult(root: HTMLElement, ui: RenterInsuranceCoverageGapCalculatorUI): void {
+  root.dataset.status = 'invalid';
+  ['total', 'gap', 'ratio', 'payout', 'out-of-pocket'].forEach((key) => setText(root, `[data-ric-${key}]`, '—'));
+  setText(root, '[data-ric-status]', ui.labelInvalidInput);
+  setText(root, '[data-ric-status-text]', '');
+  root.querySelector<HTMLElement>('[data-ric-contents-fill]')?.style.setProperty('width', '0%');
+  root.querySelector<HTMLElement>('[data-ric-limit-line]')?.style.setProperty('left', '0%');
+  root.querySelector<HTMLElement>('[data-ric-loss-mark]')?.style.setProperty('left', '0%');
+  root.querySelector('[data-ric-largest-list]')?.replaceChildren();
+}
+
+export { formatMoney };

package/src/tool/renterInsuranceCoverageGapCalculator/entry.ts

@@ -0,0 +1,28 @@
+import type { FinanceToolEntry, ToolLocaleContent } from '../../types';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+export type RenterInsuranceCoverageGapCalculatorLocaleContent = ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI>;
+
+export const renterInsuranceCoverageGapCalculator: FinanceToolEntry<RenterInsuranceCoverageGapCalculatorUI> = {
+  id: 'renter-insurance-coverage-gap-calculator',
+  icons: { bg: 'mdi:home-alert', fg: 'mdi:shield-home' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').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/renterInsuranceCoverageGapCalculator/evaluator.ts

@@ -0,0 +1,17 @@
+import type { CoverageStatus, RenterInsuranceResult } from './logic';
+import type { RenterInsuranceCoverageGapCalculatorUI } from './ui';
+
+export interface CoverageEvaluation {
+  status: CoverageStatus;
+  label: string;
+  text: string;
+}
+
+export function evaluateCoverage(result: RenterInsuranceResult, ui: RenterInsuranceCoverageGapCalculatorUI): CoverageEvaluation {
+  const content: Record<CoverageStatus, { label: string; text: string }> = {
+    safe: { label: ui.labelStatusSafe, text: ui.labelStatusSafeText },
+    review: { label: ui.labelStatusReview, text: ui.labelStatusReviewText },
+    exposed: { label: ui.labelStatusExposed, text: ui.labelStatusExposedText },
+  };
+  return { status: result.status, ...content[result.status] };
+}

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

@@ -0,0 +1,40 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { RenterInsuranceCoverageGapCalculatorUI } from '../ui';
+
+export const ui: RenterInsuranceCoverageGapCalculatorUI = {
+  labelPolicyLimit: 'Deckungssumme Hausrat', labelDeductible: 'Selbstbeteiligung', labelSampleLoss: 'Beispielschaden', labelCurrency: 'Währung', labelApproximateRates: 'Die Umrechnung nutzt ungefähre Planungsfaktoren und keine Live-Wechselkurse.', labelPolicyBoundary: 'Versicherungsgrenze', labelSetLimit: 'Grenze festlegen', labelPolicyBoundaryHint: 'Übernimm die Hausratwerte aus deiner Police und prüfe anschließend einen möglichen Schaden.', labelInventory: 'Ersatzwert-Inventar', labelInventoryHint: 'Schätze je Kategorie, was der komplette Ersatz heute kosten würde.', labelPolicyLimitHelp: 'Nutze die Hausratdeckung aus der Police, nicht die Gebäudesumme.', labelDeductibleHelp: 'Trage die Selbstbeteiligung für einen Hausratschaden ein.', labelSampleLossHelp: 'Dient nur zur Darstellung eines beispielhaften Schadenfalls nach der Lücke.', labelTotalContents: 'Geschätzter Hausratwert', labelCoverageGap: 'Mögliche Deckungslücke', labelCoverageRatio: 'Geschätzter Deckungsgrad', labelEstimatedPayout: 'Beispielauszahlung', labelOutOfPocket: 'Beispielhafte Eigenzahlung', labelStatus: 'Deckungseinschätzung', labelStatusSafe: 'Grenze deckt Inventar', labelStatusReview: 'Kleine Lücke prüfen', labelStatusExposed: 'Hausrat ist unterversichert', labelStatusSafeText: 'Die eingetragene Hausratgrenze erreicht mindestens den Ersatzwert. Prüfe Sonderlimits für einzelne Gegenstände zusätzlich.', labelStatusReviewText: 'Die Grenze liegt nahe am Inventarwert, aber eine kleine Lücke bleibt. Prüfe teure Gegenstände und neue Anschaffungen.', labelStatusExposedText: 'Die Grenze liegt unter dem Inventarwert. Prüfe die Police, bevor du dich bei einem Totalschaden darauf verlässt.', labelLargestCategories: 'Größte Inventarkategorien', labelCoverageLine: 'Deckungssumme', labelReplacementValue: 'Ersatzwert', labelLimitMarker: 'Markierung der Grenze', labelLossScenario: 'Schadenszenario', labelIllustrativePayout: 'Nur ein Beispiel: Eine Unterversicherungsregel muss auf deine Police nicht zutreffen.', labelReset: 'Beispiel zurücksetzen', labelCopy: 'Zusammenfassung kopieren', labelCopied: 'Zusammenfassung kopiert', labelCopyFailed: 'Ergebnis manuell aus dem Feld kopieren', labelInvalidInput: 'Prüfe den markierten Wert', labelMethodTitle: 'So funktioniert die Schätzung', labelMethodText: 'Das Tool addiert deine Kategoriewerte und vergleicht sie mit der Hausratdeckung. Die Lücke ist die positive Differenz. Die Beispielauszahlung wendet den Deckungsgrad auf den Schaden an und zieht die Selbstbeteiligung ab. Das ist ein Planungsmodell und keine Vorhersage einer Regulierung. Deine Police kann Einzelgrenzen, Neuwertregeln, Ausschlüsse, Erstes-Risiko-Deckung oder eine andere Behandlung von Unterversicherung vorsehen.', labelPrivacyNote: 'Dein Inventar bleibt in diesem Browser. Konto, Upload und Serverberechnung sind nicht erforderlich.', labelAmountPlaceholder: '0,00', labelCategoryFurniture: 'Möbel und Dekoration', labelCategoryElectronics: 'Elektronik', labelCategoryClothing: 'Kleidung und Schuhe', labelCategoryKitchen: 'Küche und Geräte', labelCategoryPersonal: 'Persönliche Gegenstände', labelCategoryOther: 'Sonstiger Hausrat',
+};
+
+const slug = 'mieterversicherung-unterversicherung-hausrat-rechner';
+const title = 'Rechner für die Deckungslücke bei der Hausratversicherung';
+const description = 'Prüfe, ob die Hausratdeckung deiner Mieterversicherung den Ersatzwert deiner Sachen erreicht. Vergleiche Inventar, Versicherungssumme, Selbstbeteiligung und einen Beispielschaden direkt im Browser.';
+const faq = [
+  { question: 'Was misst dieser Rechner für die Hausratversicherung?', answer: 'Er addiert die von dir eingetragenen Ersatzwerte und vergleicht die Summe mit der Hausratdeckung. Die Differenz zeigt als Planungsschätzung, welcher Betrag möglicherweise außerhalb der Grenze liegt.' },
+  { question: 'Welchen Wert soll ich für mein Inventar eintragen?', answer: 'Nutze realistische aktuelle Ersatzkosten für Möbel, Elektronik, Kleidung, Geräte und persönliche Gegenstände. Prüfe, ob deine Police den Neuwert oder eine andere Bewertungsgrundlage verlangt.' },
+  { question: 'Beweist das Ergebnis eine Unterversicherung?', answer: 'Nein. Das Ergebnis hängt von deinem Inventar, dem Vertrag und deinen Bewertungsannahmen ab. Einzelgrenzen, Ausschlüsse, besondere Vereinbarungen und Unterversicherungsklauseln können einen Schaden anders behandeln.' },
+  { question: 'Warum zeigt der Rechner eine Beispielauszahlung?', answer: 'Sie macht sichtbar, was ein einfaches proportionales Modell für den eingetragenen Schaden nach Abzug der Selbstbeteiligung ergeben würde. Sie sagt nicht voraus, was der Versicherer tatsächlich zahlt.' },
+  { question: 'Soll ich Einbauten und Ausstattung des Vermieters einrechnen?', answer: 'Nur Gegenstände, die laut Police zu deiner Hausratdeckung gehören. Haftpflicht, Gebäude, Einbauten und Hausrat können getrennte Bereiche sein und sollten nicht künstlich zusammengezählt werden.' },
+];
+const howTo = [
+  { name: 'Ersatzwert-Inventar erstellen', text: 'Gehe durch alle Räume und trage ein, was ein Ersatz des Hausrats heute kosten würde. Ordne die Werte den sechs Kategorien zu, damit die größten Posten sichtbar bleiben.' },
+  { name: 'Hausratgrenze eintragen', text: 'Übernimm die Versicherungssumme aus dem Versicherungsschein oder Angebot. Verwende nicht die Gebäude- oder Haftpflichtsumme.' },
+  { name: 'Selbstbeteiligung und Schaden ergänzen', text: 'Trage die Selbstbeteiligung und einen Beispielschaden ein, um eine beispielhafte Eigenzahlung zu sehen.' },
+  { name: 'Entscheidungsgrenze prüfen', text: 'Bei einer Lücke solltest du teure Gegenstände, Einzelgrenzen, Wertsachen und neue Anschaffungen mit Versicherer oder Makler prüfen.' },
+];
+export const content: ToolLocaleContent<RenterInsuranceCoverageGapCalculatorUI> = { slug, title, description, ui, seo: [
+  { type: 'title', text: 'Vergleiche die Grenze mit dem Wert deines Hausrats', level: 2 },
+  { type: 'paragraph', html: '<p>Eine Hausratversicherung wird leicht zu niedrig angesetzt, wenn die Summe nur grob gewählt statt Raum für Raum ermittelt wird. Dieser Rechner macht deine eigenen Ersatzschätzungen als Deckungsgrenze sichtbar, bevor du einen Schaden melden musst.</p>' },
+  { type: 'title', text: 'Das solltest du vor der Berechnung sammeln', level: 2 },
+  { type: 'list', items: ['Ersatzwerte für Möbel, Elektronik, Kleidung, Geräte und persönliche Gegenstände.', 'Die Hausratdeckung aus dem Versicherungsschein, getrennt von Gebäude und Haftpflicht.', 'Die Selbstbeteiligung für einen Hausratschaden.', 'Einen realistischen Beispielschaden, wenn du die Beispielauszahlung prüfen möchtest.'] },
+  { type: 'title', text: 'So liest du die Deckungslücke', level: 2 },
+  { type: 'paragraph', html: '<p>Die Lücke ist der Inventarwert oberhalb der Grenze. Null bedeutet, dass beide Summen unter deinen Annahmen übereinstimmen; es bestätigt nicht die Deckung jedes einzelnen Gegenstands. Eine positive Lücke ist ein Anlass, Bewertungsgrundlage, Einzelgrenzen, Ausschlüsse und Unterversicherungsklauseln zu prüfen.</p>' },
+  { type: 'table', headers: ['Signal', 'Aussage', 'Nächster sinnvoller Schritt'], rows: [['Grenze deckt Inventar', 'Die Grenze erreicht mindestens die eingetragene Ersatzsumme.', 'Wertsachen, Einzelgrenzen und Ausschlüsse prüfen.'], ['Kleine Lücke prüfen', 'Die Grenze liegt nahe am Wert, doch neue Käufe oder Rundungen können zählen.', 'Die größten Kategorien neu bewerten und die Summe anpassen.'], ['Hausrat ist unterversichert', 'Die Grenze liegt deutlich unter dem Ersatzwert.', 'Neues Angebot anfordern oder die Unterversicherungsregel klären.']] },
+  { type: 'title', text: 'Grenzen der Schätzung', level: 2 },
+  { type: 'paragraph', html: '<p>Das Tool liest keine Police, entscheidet nicht über die Deckung und berechnet keine verbindliche Entschädigung. Das Schadenbeispiel nutzt ein einfaches proportionales Modell und zieht die Selbstbeteiligung ab. Verträge können andere Klauseln, Wertansätze, Ausschlüsse oder Erstes-Risiko-Regeln enthalten.</p>' },
+  { type: 'tip', title: 'Tipp zur Dokumentation', html: '<p>Bewahre Rechnungen, Fotos und ein datiertes Inventar für wertvolle Sachen auf. Der Financial Ombudsman Service erläutert, warum fehlende Ersatzwertberechnung zu Unterversicherung führen kann; das spanische Versicherungsvertragsgesetz beschreibt die Versicherungssumme als maximale Entschädigung und eine proportionale Regel bei Unterversicherung, sofern die Police nichts anderes bestimmt.</p>' },
+], faq, bibliography, howTo, schemas: [
+  { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+  { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) },
+  { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'FinanceApplication', operatingSystem: 'All', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+] };