@jjlmoya/utils-civic 1.6.0 → 1.8.0

package/src/tool/public-budget-analyzer/controller.ts

@@ -0,0 +1,84 @@
+import { analyzeBudgetRecords, exampleBudgetRecords, parseBudgetText, type BudgetAnalysis } from './logic';
+import { loadSavedBudget, saveBudgetState } from './storage';
+import { renderAnalysis, reviewedCsv } from './dom-views';
+import type { PublicBudgetUI } from './ui';
+
+function getElement<T extends HTMLElement>(root: HTMLElement, selector: string): T | undefined {
+  return root.querySelector<T>(selector) ?? undefined;
+}
+
+function fileFormat(file: File): 'csv' | 'json' {
+  return file.name.toLowerCase().endsWith('.json') ? 'json' : 'csv';
+}
+
+function readFile(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ''));
+    reader.onerror = () => reject(new Error('read failed'));
+    reader.readAsText(file);
+  });
+}
+
+function downloadCsv(analysis: BudgetAnalysis): void {
+  const blob = new Blob([reviewedCsv(analysis)], { type: 'text/csv;charset=utf-8' });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = 'public-budget-reviewed.csv';
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+
+function showMessage(target: HTMLElement, message: string, tone: 'error' | 'info'): void {
+  target.innerHTML = `<p class="budget-inline-message budget-inline-${tone}" role="status">${message}</p>`;
+}
+
+function analyzeText(text: string, format: 'csv' | 'json', target: HTMLElement, ui: PublicBudgetUI): BudgetAnalysis | undefined {
+  const parsed = parseBudgetText(text, format);
+  if (parsed.errors.length) {
+    showMessage(target, `${ui.invalidFile} ${parsed.errors.join(' ')}`, 'error');
+    return undefined;
+  }
+  const analysis = analyzeBudgetRecords(parsed.records);
+  renderAnalysis(target, analysis, ui);
+  saveBudgetState({ format, text });
+  return analysis;
+}
+
+function renderExample(target: HTMLElement, ui: PublicBudgetUI): BudgetAnalysis {
+  const analysis = analyzeBudgetRecords(exampleBudgetRecords());
+  renderAnalysis(target, analysis, ui);
+  return analysis;
+}
+
+export function mountPublicBudgetAnalyzer(root: HTMLElement, ui: PublicBudgetUI): void {
+  const fileInput = getElement<HTMLInputElement>(root, '[data-budget-file]');
+  const result = getElement<HTMLElement>(root, '[data-budget-result]');
+  const example = getElement<HTMLButtonElement>(root, '[data-budget-example]');
+  const print = getElement<HTMLButtonElement>(root, '[data-budget-print]');
+  const download = getElement<HTMLButtonElement>(root, '[data-budget-download]');
+  const dropzone = getElement<HTMLElement>(root, '[data-budget-dropzone]');
+  if (!fileInput || !result || !example || !print || !download || !dropzone) return;
+  let latest: BudgetAnalysis | undefined;
+  const processFile = async (file: File): Promise<void> => {
+    try {
+      latest = analyzeText(await readFile(file), fileFormat(file), result, ui);
+    } catch {
+      showMessage(result, ui.fileReadError, 'error');
+    }
+  };
+  fileInput.addEventListener('change', () => { const file = fileInput.files?.[0]; if (file) void processFile(file); });
+  dropzone.addEventListener('dragover', (event) => { event.preventDefault(); dropzone.classList.add('is-dragging'); });
+  dropzone.addEventListener('dragleave', () => dropzone.classList.remove('is-dragging'));
+  dropzone.addEventListener('drop', (event) => { event.preventDefault(); dropzone.classList.remove('is-dragging'); const file = event.dataTransfer?.files[0]; if (file) void processFile(file); });
+  example.addEventListener('click', () => { latest = renderExample(result, ui); });
+  print.addEventListener('click', () => window.print());
+  download.addEventListener('click', () => { if (latest) downloadCsv(latest); });
+  const saved = loadSavedBudget();
+  if (saved) {
+    latest = analyzeText(saved.text, saved.format, result, ui);
+  } else {
+    latest = renderExample(result, ui);
+  }
+}

package/src/tool/public-budget-analyzer/dom-views.ts

@@ -0,0 +1,52 @@
+import type { PublicBudgetUI } from './ui';
+import type { BudgetAnalysis } from './logic';
+import { evaluateBudget, statusLabel } from './evaluator';
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[character] || character));
+}
+
+export function formatAmount(value: number, currency?: string): string {
+  const code = currency && /^[A-Za-z]{3}$/.test(currency) ? currency.toUpperCase() : undefined;
+  return new Intl.NumberFormat('en-US', { style: code ? 'currency' : 'decimal', currency: code || 'USD', maximumFractionDigits: 2 }).format(value);
+}
+
+function formatPercent(value: number | undefined): string {
+  return value === undefined ? 'Not available' : `${new Intl.NumberFormat('en-US', { maximumFractionDigits: 1, signDisplay: 'exceptZero' }).format(value * 100)}%`;
+}
+
+function metric(label: string, value: string): string {
+  return `<div class="budget-metric"><span>${escapeHtml(label)}</span><strong>${escapeHtml(value)}</strong></div>`;
+}
+
+function categoryBars(analysis: BudgetAnalysis, ui: PublicBudgetUI): string {
+  const positive = analysis.categories.filter((category) => category.amount > 0).slice(0, 8);
+  if (!positive.length) return `<p class="budget-empty-note">${escapeHtml(ui.noData)}</p>`;
+  return positive.map((category, index) => {
+    const width = analysis.positiveTotal ? Math.max(2, category.amount / analysis.positiveTotal * 100) : 0;
+    const shade = index % 2 === 0 ? 'budget-segment-a' : 'budget-segment-b';
+    return `<div class="budget-category-row"><div class="budget-category-label"><span>${escapeHtml(category.path.join(' / '))}</span><strong>${formatAmount(category.amount, analysis.currency)}</strong></div><div class="budget-bar"><span class="${shade}" style="--segment-width:${width}%"></span></div><small>${escapeHtml(ui.shareLabel)} ${formatPercent(category.share)} · ${escapeHtml(ui.sourceLabel)} ${category.sourceRows.join(', ')}</small></div>`;
+  }).join('');
+}
+
+function tableRows(analysis: BudgetAnalysis): string {
+  return analysis.categories.map((category) => `<tr><th scope="row">${escapeHtml(category.path.join(' / '))}</th><td>${formatAmount(category.amount, analysis.currency)}</td><td>${formatPercent(category.share)}</td><td>${formatPercent(category.variation)}</td><td>${category.sourceRows.join(', ')}</td></tr>`).join('');
+}
+
+function notices(analysis: BudgetAnalysis, ui: PublicBudgetUI): string {
+  const warnings = analysis.warnings.length ? `<section class="budget-notice budget-notice-warning"><h3>${escapeHtml(ui.warningsHeading)}</h3><ul>${analysis.warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join('')}</ul></section>` : '';
+  const errors = analysis.errors.length ? `<section class="budget-notice budget-notice-error"><h3>${escapeHtml(ui.errorsHeading)}</h3><ul>${analysis.errors.map((error) => `<li>${escapeHtml(error)}</li>`).join('')}</ul></section>` : '';
+  return `${errors}${warnings}`;
+}
+
+export function renderAnalysis(target: HTMLElement, analysis: BudgetAnalysis, ui: PublicBudgetUI): void {
+  const status = evaluateBudget(analysis);
+  const topCategory = analysis.categories[0]?.path.join(' / ') || ui.noData;
+  target.innerHTML = `<div class="budget-result-head"><div><span class="budget-status budget-status-${status}">${escapeHtml(statusLabel(status))}</span><h2>${escapeHtml(ui.resultHeading)}</h2></div><p>${analysis.period ? escapeHtml(analysis.period) : ''}</p></div>${analysis.rows.length ? `<div class="budget-metrics">${metric(ui.totalLabel, formatAmount(analysis.total, analysis.currency))}${metric(ui.perCapitaLabel, analysis.perCapita === undefined ? 'Not available' : formatAmount(analysis.perCapita, analysis.currency))}${metric(ui.variationLabel, formatPercent(analysis.variation))}${metric(ui.topCategoryLabel, topCategory)}</div><div class="budget-landscape" role="img" aria-label="Budget categories sized by their positive amounts"><div class="budget-landscape-axis"><span>0</span><span>${formatAmount(analysis.positiveTotal, analysis.currency)}</span></div>${categoryBars(analysis, ui)}</div><div class="budget-detail"><div class="budget-detail-heading"><h3>${escapeHtml(ui.tableHeading)}</h3><span>${analysis.rows.length} ${escapeHtml(ui.rowsLabel)} / ${analysis.categories.length} ${escapeHtml(ui.categoriesLabel)}</span></div><div class="budget-table-wrap"><table><thead><tr><th scope="col">${escapeHtml(ui.categoryLabel)}</th><th scope="col">${escapeHtml(ui.amountLabel)}</th><th scope="col">${escapeHtml(ui.shareLabel)}</th><th scope="col">${escapeHtml(ui.variationLabel)}</th><th scope="col">${escapeHtml(ui.sourceRowsLabel)}</th></tr></thead><tbody>${tableRows(analysis)}</tbody></table></div></div>${notices(analysis, ui)}` : `<p class="budget-empty-note">${escapeHtml(ui.noData)}</p>`}<div class="budget-facts"><div><span>${escapeHtml(ui.positiveTotalLabel)}</span><strong>${formatAmount(analysis.positiveTotal, analysis.currency)}</strong></div><div><span>${escapeHtml(ui.previousTotalLabel)}</span><strong>${analysis.previousTotal === undefined ? escapeHtml(ui.noPreviousData) : formatAmount(analysis.previousTotal, analysis.currency)}</strong></div><div><span>${escapeHtml(ui.populationLabel)}</span><strong>${analysis.population === undefined ? 'Not available' : new Intl.NumberFormat('en-US').format(analysis.population)}</strong></div></div>`;
+}
+
+export function reviewedCsv(analysis: BudgetAnalysis): string {
+  const header = ['category', 'amount', 'share', 'variation', 'sourceRows'];
+  const rows = analysis.categories.map((category) => [category.path.join(' > '), String(category.amount), category.share === undefined ? '' : String(category.share), category.variation === undefined ? '' : String(category.variation), category.sourceRows.join('|')]);
+  return [header, ...rows].map((row) => row.map((value) => `"${value.replace(/"/g, '""')}"`).join(',')).join('\n');
+}

package/src/tool/public-budget-analyzer/entry.ts

@@ -0,0 +1,27 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { PublicBudgetUI } from './ui';
+
+export type PublicBudgetLocaleContent = ToolLocaleContent<PublicBudgetUI>;
+
+export const publicBudgetAnalyzer: CivicToolEntry<PublicBudgetUI> = {
+  id: 'public-budget-analyzer',
+  phase: 'localized',
+  icons: { bg: 'mdi:bank-outline', fg: 'mdi:chart-pie' },
+  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),
+  },
+};

package/src/tool/public-budget-analyzer/evaluator.ts

@@ -0,0 +1,15 @@
+import type { BudgetAnalysis } from './logic';
+
+export type BudgetStatus = 'ready' | 'review' | 'empty';
+
+export function evaluateBudget(analysis: BudgetAnalysis): BudgetStatus {
+  if (!analysis.rows.length) return 'empty';
+  if (analysis.errors.length || analysis.warnings.length) return 'review';
+  return 'ready';
+}
+
+export function statusLabel(status: BudgetStatus): string {
+  if (status === 'ready') return 'Ready to review';
+  if (status === 'review') return 'Review data notes';
+  return 'Waiting for data';
+}

package/src/tool/public-budget-analyzer/i18n/de.ts

@@ -0,0 +1,115 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { PublicBudgetLocaleContent } from '../entry';
+import type { PublicBudgetUI } from '../ui';
+
+const ui: PublicBudgetUI = {
+  uploadLabel: 'Budget CSV oder JSON hier ablegen',
+  uploadHelp: 'Pflichtfelder: Kategorie und Betrag. Optional: Bevölkerung, Zeitraum, priorAmount, Währung und übergeordnete Kategorie.',
+  loadExample: 'Beispielbudget laden',
+  supportedFormat: 'CSV oder JSON, nur in diesem Browser verarbeitet',
+  tableHeading: 'Quellzeilen und Kategoriesummen',
+  categoryLabel: 'Kategorie',
+  amountLabel: 'Betrag',
+  populationLabel: 'Bevölkerung',
+  sourceRowsLabel: 'Quellzeilen',
+  analyzeEmpty: 'Wähle eine Datei oder lade das Beispiel, um ein Budget zu prüfen.',
+  resultHeading: 'Budgetlandschaft',
+  totalLabel: 'Gesamtausgaben',
+  perCapitaLabel: 'Ausgaben pro Person',
+  variationLabel: 'Änderung gegenüber dem Vorzeitraum',
+  topCategoryLabel: 'Größte Kategorie',
+  shareLabel: 'Anteil an der Summe',
+  sourceLabel: 'Quellzeilen',
+  noData: 'Noch keine gültigen Budgetzeilen verfügbar.',
+  warningsHeading: 'Zu prüfende Warnungen',
+  errorsHeading: 'Nicht einbezogene Zeilen',
+  methodHeading: 'Angewandte Methode',
+  methodText: 'Das Werkzeug prüft Pflichtfelder, bewahrt jede Quellzeile, gruppiert exakte Kategoriepfade und berechnet Summen aus normalisierten Beträgen. Der Kategorieanteil ist der Betrag geteilt durch die positive Gesamtsumme. Die Pro Kopf Ausgabe teilt die Summe durch den ersten einheitlichen positiven Bevölkerungswert. Die Zeitänderung ist die Differenz geteilt durch den absoluten Vorbetrag.',
+  limitsHeading: 'Was dieses Werkzeug nicht leistet',
+  limitsText: 'Es beweist nicht, dass ein Budget vollständig, vergleichbar, rechtmäßig, effizient, fair, unparteiisch oder korrekt klassifiziert ist. Es prüft die Quelle nicht, bewertet keine Politik, rechnet Währungen nicht um und erkennt nicht, ob eine Zeile eine Bewilligung, Verpflichtung, Zahlung oder Prognose ist.',
+  edgeCasesHeading: 'Sonderfälle und Datenwarnungen',
+  edgeCasesText: 'Gemischte Währungen, wechselnde Bevölkerungen, doppelte Kategorien, negative Anpassungen, Elternzeilen neben Kindzeilen, lokale Zahlenformate und ein Vorbetrag von null brauchen menschliche Prüfung. Die ursprüngliche Zeilennummer bleibt sichtbar, damit jede Summe zur Eingabe zurückverfolgt werden kann.',
+  downloadCsv: 'Geprüfte Tabelle herunterladen',
+  printAction: 'Analyse drucken',
+  rowsLabel: 'gültige Zeilen',
+  categoriesLabel: 'Kategorien',
+  positiveTotalLabel: 'Visualisierte positive Beträge',
+  previousTotalLabel: 'Vorherige Summe',
+  invalidFile: 'Die Datei konnte nicht als gefüllte CSV oder JSON Tabelle gelesen werden.',
+  fileReadError: 'Die Datei konnte in diesem Browser nicht gelesen werden.',
+  exampleName: 'Beispiel eines kommunalen Budgets',
+  noPreviousData: 'Kein vergleichbarer Vorzeitraum angegeben.',
+};
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Analyse öffentlicher Haushalte',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Öffentliche Budgettabellen lokal nach Ausgaben, Kategorien, Pro Kopf Werten und Zeitänderungen prüfen.',
+  url: 'https://gamebob.dev/de/oeffentliche-haushaltsanalyse-ausgaben',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'Welche Spalten braucht die Analyse?', acceptedAnswer: { '@type': 'Answer', text: 'Jede Zeile braucht eine Kategorie und einen numerischen Betrag. Bevölkerung, Zeitraum, priorAmount, Währung und übergeordnete Kategorie sind optional.' } },
+    { '@type': 'Question', name: 'Wie werden Ausgaben pro Person berechnet?', acceptedAnswer: { '@type': 'Answer', text: 'Die Gesamtsumme wird durch den ersten einheitlichen positiven Bevölkerungswert geteilt. Abweichende Nenner bleiben sichtbar und erzeugen eine Warnung.' } },
+    { '@type': 'Question', name: 'Was passiert mit doppelten Kategorien?', acceptedAnswer: { '@type': 'Answer', text: 'Gleiche Kategoriepfade werden addiert. Die zugehörigen Quellzeilen bleiben sichtbar, damit eine echte Aufteilung von einer möglichen Doppelzählung unterschieden werden kann.' } },
+    { '@type': 'Question', name: 'Beweist die Analyse, dass ein Budget gut oder fair ist?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Sie beschreibt nur die gelieferten Zahlen und bewertet weder Vollständigkeit noch Rechtmäßigkeit, Effizienz, Fairness oder Ergebnisse.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Eine öffentliche Budgettabelle analysieren',
+  step: [
+    { '@type': 'HowToStep', name: 'Tabelle vorbereiten', text: 'Erstelle eine CSV oder JSON Tabelle mit einer Kategorie und einem Betrag je Zeile. Halte Währung und Rechnungsgrundlage einheitlich.' },
+    { '@type': 'HowToStep', name: 'Kontext ergänzen', text: 'Füge Bevölkerung, Zeitraum, priorAmount, Währung oder übergeordnete Kategorie nur bei konsistenter Bedeutung hinzu.' },
+    { '@type': 'HowToStep', name: 'Datei laden', text: 'Lege die Datei ab oder lade das Beispiel, um Aufbau und lokale Prüfung zu sehen.' },
+    { '@type': 'HowToStep', name: 'Landschaft lesen', text: 'Nutze die proportionalen Balken für die Zusammensetzung und die Tabelle für genaue Beträge, Änderungen und Quellzeilen.' },
+    { '@type': 'HowToStep', name: 'Warnungen prüfen', text: 'Klär gemischte Währungen, doppelte Pfade, negative Anpassungen, Null Nenner und Elternzeilen, bevor du Schlussfolgerungen ziehst.' },
+  ],
+};
+
+export const content: PublicBudgetLocaleContent = {
+  slug: 'oeffentliche-haushaltsanalyse-ausgaben',
+  title: 'Analyse öffentlicher Haushalte',
+  description: 'Prüfe eine öffentliche Budgettabelle lokal und sieh Gesamtausgaben, Kategorieanteile, Pro Kopf Werte, Änderungen und die Quellzeilen hinter jeder Summe.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Eine öffentliche Budgettabelle prüfbar machen', level: 2 },
+    { type: 'paragraph', html: 'Öffentliche Budgetdateien vermischen oft Kategorien, Rechnungszeiträume, Bevölkerungswerte und Anpassungen. Diese Analyse bewahrt die Quellzeilen, prüft Pflichtfelder und macht aus denselben normalisierten Daten Summen, Anteile, Ausgaben pro Person und Zeitänderungen.' },
+    { type: 'paragraph', html: 'Das Ergebnis beschreibt Zahlen und spricht kein politisches Urteil. Eine große Kategorie kann eine gesetzliche Aufgabe, eine einmalige Investition, einen Transfer oder eine andere Abgrenzung widerspiegeln. Die Ansicht zeigt diese Muster, damit die Originalquelle gezielter geprüft werden kann.' },
+    { type: 'title', text: 'Was die Berechnungen bedeuten', level: 2 },
+    { type: 'paragraph', html: 'Die Gesamtsumme addiert alle gültigen numerischen Beträge einschließlich negativer Anpassungen. Ein Kategorieanteil ist der gruppierte Betrag geteilt durch die positive Summe. Positive Beträge werden proportional dargestellt; negative Beträge bleiben in der Tabelle, weil eine Flächendarstellung ihre Bedeutung verfälschen würde.' },
+    { type: 'table', headers: ['Ausgabe', 'Berechnung', 'Prüffrage'], rows: [['Gesamtausgaben', 'Summe der normalisierten Beträge', 'Haben alle Zeilen dieselbe Rechnungsgrundlage?'], ['Kategorieanteil', 'Kategoriebetrag geteilt durch positive Summe', 'Überlappen Elternkategorien und Kinder?'], ['Ausgaben pro Person', 'Summe geteilt durch positiven Bevölkerungsnenner', 'Beschreibt die Bevölkerung denselben Ort und Zeitraum?'], ['Zeitänderung', 'Aktueller Betrag minus Vorbetrag geteilt durch absoluten Vorbetrag', 'Sind die Zeiträume vergleichbar und ist der Ausgangswert ungleich null?']] },
+    { type: 'title', text: 'Vergleichbare Daten vorbereiten', level: 2 },
+    { type: 'paragraph', html: 'Verwende eine Währung und eine klare Bedeutung des Betrags für jede Zeile. Bewilligung, Verpflichtung, Zahlung und Prognose können gültige Zahlen sein, beantworten aber unterschiedliche Fragen. Halte diese Bedeutung neben der Quelle fest, denn das Werkzeug erkennt sie nicht aus dem Spaltennamen.' },
+    { type: 'list', items: ['Nutze eine Zeile je Kategorie oder gib für eine bewusste Hierarchie eine übergeordnete Kategorie an.', 'Halte Bevölkerungswerte konsistent und mische keine Einwohner, Wahlberechtigten, Haushalte oder Nutzer.', 'Verwende priorAmount nur bei gleicher Kategorie und Rechnungsgrundlage im Vorzeitraum.', 'Prüfe doppelte Kategoriepfade und Elternzeilen auf unbeabsichtigte Doppelzählung.', 'Bewahre die geprüfte Tabelle zusammen mit Quelle und Annahmen auf.'] },
+    { type: 'tip', title: 'Ein Anteil ist keine Prioritätswertung', html: 'Die größte Kategorie ist nicht automatisch die wichtigste, verschwenderischste oder erfolgreichste. Nutze die Ansicht für Größenordnung und Änderungen und lies danach Quellen und Ergebnisse des Dienstes.' },
+    { type: 'title', text: 'Warnungen vor Schlussfolgerungen lesen', level: 2 },
+    { type: 'paragraph', html: 'Doppelte Pfade werden gruppiert, damit die Summe nicht still zu niedrig ausfällt. Die Quellzeilen zeigen jedoch, ob diese Gruppierung beabsichtigt ist. Gemischte Währungen werden nicht umgerechnet. Eine Bevölkerung von null entfernt den Pro Kopf Wert, ein Vorbetrag von null die Prozentänderung.' },
+    { type: 'paragraph', html: 'Verschachtelte Kategorien brauchen besondere Vorsicht. Enthält eine Tabelle sowohl Bildung als auch Bildung > Schulen, kann eine Addition dieselben Ausgaben doppelt zählen. Die Analyse warnt vor solchen Pfaden, aber nur die Methodik der Quelle kann klären, ob die Elternzeile eine Zwischensumme oder eine eigenständige Position ist.' },
+    { type: 'title', text: 'Nach dem ersten Durchlauf handeln', level: 2 },
+    { type: 'paragraph', html: 'Nutze die Quellzeilen, um zur offiziellen Datei zurückzugehen und jede Korrektur oder Auslegung zu dokumentieren. Vergleiche nur gleichartige Zeiträume, bewahre negative Anpassungen als Anpassungen und entferne Zwischensummen erst dann, wenn die Quelle bestätigt, dass sie bereits enthalten sind.' },
+    { type: 'tip', title: 'Die Datengrenze sichtbar halten', html: 'Dies ist eine lokale beschreibende Analyse. Sie prüft weder Vollständigkeit noch eine amtliche Klassifikation, rechnet Währungen um oder beweist einen Ursache Wirkung Zusammenhang zwischen Ausgaben und Ergebnissen.' },
+  ],
+  faq: [
+    { question: 'Welche Spalten braucht die Analyse?', answer: 'Jede Zeile braucht Kategorie und numerischen Betrag. Bevölkerung, Zeitraum, priorAmount, Währung und übergeordnete Kategorie sind optional.' },
+    { question: 'Wie werden Ausgaben pro Person berechnet?', answer: 'Die Gesamtsumme wird durch den ersten konsistenten positiven Bevölkerungswert geteilt. Uneinheitliche Nenner erzeugen eine Warnung.' },
+    { question: 'Was passiert mit doppelten Kategorien?', answer: 'Gleiche Kategoriepfade werden addiert und ihre Quellzeilen bleiben zur Prüfung sichtbar.' },
+    { question: 'Beweist die Analyse, dass ein Budget gut oder fair ist?', answer: 'Nein. Sie beschreibt Zahlen und kann Vollständigkeit, Rechtmäßigkeit, Effizienz, Fairness oder Ergebnisse nicht feststellen.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Tabelle vorbereiten', text: 'Erstelle eine CSV oder JSON Tabelle mit Kategorie und Betrag je Zeile sowie gleicher Währung und Rechnungsgrundlage.' },
+    { name: 'Kontext ergänzen', text: 'Füge Bevölkerung, Zeitraum, priorAmount, Währung oder übergeordnete Kategorie nur bei konsistenter Bedeutung hinzu.' },
+    { name: 'Datei laden', text: 'Lege die Datei ab oder lade das Beispiel, um den erwarteten Aufbau zu sehen.' },
+    { name: 'Landschaft lesen', text: 'Nutze proportionale Balken für die Zusammensetzung und die Tabelle für genaue Werte, Änderungen und Quellzeilen.' },
+    { name: 'Warnungen prüfen', text: 'Klär gemischte Währungen, doppelte Pfade, negative Anpassungen, Null Nenner und Elternzeilen vor einer Schlussfolgerung.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};

package/src/tool/public-budget-analyzer/i18n/en.ts

@@ -0,0 +1,78 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { PublicBudgetLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Public Budget Analyzer',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Inspect spending totals, category shares, per capita values, and period changes from a local public budget table.',
+  url: 'https://gamebob.dev/en/public-budget-analyzer',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What columns does the analyzer need?', acceptedAnswer: { '@type': 'Answer', text: 'Each row needs a category and a numeric amount. Population, period, priorAmount, currency, and parentCategory are optional, so the analyzer can still show totals and category composition when those fields are missing.' } },
+    { '@type': 'Question', name: 'How is spending per person calculated?', acceptedAnswer: { '@type': 'Answer', text: 'The total amount is divided by the first consistent positive population value found in the table. If population values differ, the tool keeps the calculation but displays a warning so the denominator can be checked.' } },
+    { '@type': 'Question', name: 'What happens to duplicate categories?', acceptedAnswer: { '@type': 'Answer', text: 'Rows with the same category path are added together and their source row numbers remain visible. Grouping is transparent, but duplicate rows may be a real split in the source or an accidental double count.' } },
+    { '@type': 'Question', name: 'Can this prove that a budget is good or fair?', acceptedAnswer: { '@type': 'Answer', text: 'No. The analyzer describes the numbers supplied to it. It cannot establish completeness, legality, efficiency, fairness, classification quality, or whether the spending produced a desired outcome.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Analyze a public budget table',
+  step: [
+    { '@type': 'HowToStep', name: 'Prepare a table', text: 'Create a CSV or JSON table with one category and amount per row. Keep amounts on the same currency and accounting basis.' },
+    { '@type': 'HowToStep', name: 'Add context fields', text: 'Add population, period, priorAmount, currency, or parentCategory only when their denominator and meaning are consistent across the rows.' },
+    { '@type': 'HowToStep', name: 'Load the file', text: 'Drop the file into the analyzer or load the example to see the expected shape and the local validation result.' },
+    { '@type': 'HowToStep', name: 'Read the landscape', text: 'Use the proportional category bars for composition, then inspect the accessible table for exact totals, changes, and source row numbers.' },
+    { '@type': 'HowToStep', name: 'Review warnings', text: 'Resolve mixed currencies, duplicate paths, negative adjustments, zero denominators, and parent rows before drawing a policy conclusion.' },
+  ],
+};
+
+export const content: PublicBudgetLocaleContent = {
+  slug: 'public-budget-analyzer',
+  title: 'Public Budget Analyzer',
+  description: 'Inspect a public budget table locally to see total spending, category shares, per capita values, changes, and the source rows behind every aggregate.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Turn a Public Budget Table Into an Auditable View', level: 2 },
+    { type: 'paragraph', html: 'Public budget files often mix category labels, accounting periods, population denominators, and adjustments in a table that is difficult to read at a glance. This analyzer keeps the source rows in the browser, validates the required fields, and turns the same normalized data into totals, category proportions, per capita spending, and period changes.' },
+    { type: 'paragraph', html: 'The result is descriptive rather than judgmental. A large category may reflect a statutory responsibility, a one-off investment, a transfer, or a different accounting boundary. The tool makes those patterns visible so that a reviewer can ask a better question of the source document.' },
+    { type: 'title', text: 'What the Calculations Mean', level: 2 },
+    { type: 'paragraph', html: 'The total is the sum of valid numeric amounts, including negative adjustments. A category share is its grouped amount divided by the total when the total is positive. Positive amounts receive proportional bars; negative amounts remain in the table and are flagged because a treemap cannot represent them as positive area without changing their meaning.' },
+    { type: 'table', headers: ['Output', 'Calculation', 'Review question'], rows: [['Total spending', 'Sum of normalized amounts', 'Are all rows on the same accounting basis?'], ['Category share', 'Category amount divided by positive total', 'Are categories mutually exclusive or do parent rows overlap children?'], ['Spending per person', 'Total divided by a positive population denominator', 'Does the population describe the same place and period?'], ['Period change', '(Current amount minus prior amount) divided by absolute prior amount', 'Are the two periods comparable and is a zero baseline being avoided?']] },
+    { type: 'title', text: 'Prepare Data That Can Be Compared', level: 2 },
+    { type: 'paragraph', html: 'Use a single currency and an explicit amount meaning for every row. A budget authorization, an obligation, a payment, and a forecast can all be valid numbers while answering different questions. Record that meaning beside the source file because the analyzer does not infer it from a column name.' },
+    { type: 'list', items: ['Use one row per category or provide a parentCategory field for a deliberate hierarchy.', 'Keep population values consistent and do not mix residents, eligible voters, households, or service users.', 'Include priorAmount only when the prior period uses the same categories and amount basis.', 'Check duplicate category paths and parent rows for accidental double counting.', 'Keep the exported reviewed table with the original source and the assumptions used to interpret it.'] },
+    { type: 'tip', title: 'A proportion is not a priority score', html: 'A category with the largest amount is not automatically the most important, wasteful, or successful. Use the view to locate scale and changes, then read the source notes and service outcomes before evaluating a policy.' },
+    { type: 'title', text: 'Read Warnings Before Drawing Conclusions', level: 2 },
+    { type: 'paragraph', html: 'Duplicate paths are grouped so that the aggregate is not silently understated, but the source row list lets you investigate whether that grouping is intentional. Mixed currencies are never converted. A population of zero removes the per capita result, and a zero prior amount removes the percentage change because division by zero has no meaningful interpretation.' },
+    { type: 'paragraph', html: 'Nested categories need particular care. If a table contains both Education and Education > Schools as amounts, adding both may count the same spending twice. The tool warns when paths are nested, but only the source methodology can tell you whether the parent is a subtotal or an independent line.' },
+    { type: 'title', text: 'What to Do After the First Pass', level: 2 },
+    { type: 'paragraph', html: 'Use the source row numbers to return to the official file and document each correction or interpretation. Compare like with like across periods, preserve negative adjustments as adjustments, and rerun the analysis after removing subtotal rows when the source says they are already included.' },
+    { type: 'tip', title: 'Keep the data boundary visible', html: 'This is a local descriptive analysis. It does not verify that the file is complete, classify expenditure according to an official standard, reconcile currencies, or prove a causal link between spending and results.' },
+  ],
+  faq: [
+    { question: 'What columns does the analyzer need?', answer: 'Each row needs a category and a numeric amount. Population, period, priorAmount, currency, and parentCategory are optional.' },
+    { question: 'How is spending per person calculated?', answer: 'The total amount is divided by the first consistent positive population value. Inconsistent denominators produce a warning.' },
+    { question: 'What happens to duplicate categories?', answer: 'Same category paths are added together and their source row numbers remain visible for review.' },
+    { question: 'Can this prove that a budget is good or fair?', answer: 'No. It describes supplied numbers and cannot establish completeness, legality, efficiency, fairness, or outcomes.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Prepare a table', text: 'Create a CSV or JSON table with one category and amount per row on the same currency and accounting basis.' },
+    { name: 'Add context fields', text: 'Add population, period, priorAmount, currency, or parentCategory only when their meaning is consistent.' },
+    { name: 'Load the file', text: 'Drop the file into the analyzer or load the example to see the expected shape.' },
+    { name: 'Read the landscape', text: 'Use the proportional bars for composition and the table for exact values, changes, and source row numbers.' },
+    { name: 'Review warnings', text: 'Resolve mixed currencies, duplicates, negative adjustments, zero denominators, and parent rows before drawing conclusions.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};
+
+export const englishContent = content;

package/src/tool/public-budget-analyzer/i18n/es.ts

@@ -0,0 +1,115 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { PublicBudgetLocaleContent } from '../entry';
+import type { PublicBudgetUI } from '../ui';
+
+const ui: PublicBudgetUI = {
+  uploadLabel: 'Suelta aquí un CSV o JSON de presupuesto',
+  uploadHelp: 'Campos obligatorios: categoría e importe. Opcionales: población, periodo, priorAmount, moneda y categoría padre.',
+  loadExample: 'Cargar presupuesto de ejemplo',
+  supportedFormat: 'CSV o JSON, procesado solo en este navegador',
+  tableHeading: 'Filas de origen y totales por categoría',
+  categoryLabel: 'Categoría',
+  amountLabel: 'Importe',
+  populationLabel: 'Población',
+  sourceRowsLabel: 'Filas de origen',
+  analyzeEmpty: 'Elige un archivo o carga el ejemplo para revisar un presupuesto.',
+  resultHeading: 'Paisaje presupuestario',
+  totalLabel: 'Gasto total',
+  perCapitaLabel: 'Gasto por habitante',
+  variationLabel: 'Cambio frente al periodo anterior',
+  topCategoryLabel: 'Categoría mayoritaria',
+  shareLabel: 'Parte del total',
+  sourceLabel: 'Filas de origen',
+  noData: 'Todavía no hay filas presupuestarias válidas disponibles.',
+  warningsHeading: 'Advertencias que revisar',
+  errorsHeading: 'Filas no incluidas',
+  methodHeading: 'Método aplicado',
+  methodText: 'La herramienta valida los campos obligatorios, conserva cada fila de origen, agrupa las rutas exactas de categoría y calcula los totales a partir de importes normalizados. La parte de cada categoría es su importe dividido por el total cuando este es positivo. El gasto por habitante divide el total por el primer denominador de población positivo y consistente. El cambio del periodo es la diferencia dividida por el importe anterior absoluto.',
+  limitsHeading: 'Lo que esta herramienta no hace',
+  limitsText: 'No demuestra que un presupuesto sea completo, comparable, legal, eficiente, justo, imparcial o esté bien clasificado. No audita la fuente, no evalúa la calidad de una política, no convierte monedas ni identifica si una fila es una autorización, obligación, pago o previsión.',
+  edgeCasesHeading: 'Casos límite y advertencias de datos',
+  edgeCasesText: 'Las monedas mezcladas, poblaciones cambiantes, categorías duplicadas, ajustes negativos, filas padre junto a filas hijas, formatos numéricos locales y los importes anteriores iguales a cero requieren revisión humana. El navegador conserva el número de fila original para rastrear cada agregado hasta su entrada.',
+  downloadCsv: 'Descargar tabla revisada',
+  printAction: 'Imprimir análisis',
+  rowsLabel: 'filas válidas',
+  categoriesLabel: 'categorías',
+  positiveTotalLabel: 'importes positivos visualizados',
+  previousTotalLabel: 'Total anterior',
+  invalidFile: 'El archivo no se ha podido entender como una tabla CSV o JSON no vacía.',
+  fileReadError: 'El archivo no se ha podido leer en este navegador.',
+  exampleName: 'Ejemplo de presupuesto municipal',
+  noPreviousData: 'No se ha indicado un importe anterior comparable.',
+};
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Analizador de presupuesto público',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Revisa localmente gastos públicos, partes por categoría, importes por habitante y cambios entre periodos.',
+  url: 'https://gamebob.dev/es/analizador-presupuesto-publico-gasto',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: '¿Qué columnas necesita el analizador?', acceptedAnswer: { '@type': 'Answer', text: 'Cada fila necesita una categoría y un importe numérico. Población, periodo, priorAmount, moneda y categoría padre son opcionales.' } },
+    { '@type': 'Question', name: '¿Cómo se calcula el gasto por habitante?', acceptedAnswer: { '@type': 'Answer', text: 'El importe total se divide por el primer valor de población positivo y consistente. Si los denominadores cambian, la herramienta mantiene el cálculo y muestra una advertencia.' } },
+    { '@type': 'Question', name: '¿Qué ocurre con las categorías duplicadas?', acceptedAnswer: { '@type': 'Answer', text: 'Las filas con la misma ruta de categoría se suman y conservan visibles sus números de fila de origen. Así se puede distinguir una división real de una doble contabilización.' } },
+    { '@type': 'Question', name: '¿Puede demostrar que un presupuesto es bueno o justo?', acceptedAnswer: { '@type': 'Answer', text: 'No. Describe los números recibidos, pero no establece su integridad, legalidad, eficiencia, justicia, clasificación ni sus resultados.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Analizar una tabla de presupuesto público',
+  step: [
+    { '@type': 'HowToStep', name: 'Preparar una tabla', text: 'Crea una tabla CSV o JSON con una categoría y un importe por fila. Mantén la misma moneda y base contable.' },
+    { '@type': 'HowToStep', name: 'Añadir contexto', text: 'Añade población, periodo, priorAmount, moneda o categoría padre solo cuando su significado sea consistente.' },
+    { '@type': 'HowToStep', name: 'Cargar el archivo', text: 'Suelta el archivo en el analizador o carga el ejemplo para ver la estructura esperada y la validación local.' },
+    { '@type': 'HowToStep', name: 'Leer el paisaje', text: 'Usa las barras proporcionales para la composición y la tabla accesible para importes, cambios y filas de origen exactos.' },
+    { '@type': 'HowToStep', name: 'Revisar advertencias', text: 'Aclara monedas mezcladas, rutas duplicadas, ajustes negativos, denominadores cero y filas padre antes de concluir.' },
+  ],
+};
+
+export const content: PublicBudgetLocaleContent = {
+  slug: 'analizador-presupuesto-publico-gasto',
+  title: 'Analizador de presupuesto público',
+  description: 'Revisa localmente una tabla de presupuesto público para ver gasto total, partes por categoría, gasto por habitante, cambios y las filas de origen detrás de cada agregado.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Convierte una tabla de presupuesto público en una vista auditable', level: 2 },
+    { type: 'paragraph', html: 'Los archivos de presupuesto público suelen mezclar etiquetas de categoría, periodos contables, denominadores de población y ajustes en una tabla difícil de leer de un vistazo. Este analizador conserva las filas de origen, valida los campos necesarios y convierte los mismos datos normalizados en totales, proporciones, gasto por habitante y cambios entre periodos.' },
+    { type: 'paragraph', html: 'El resultado es descriptivo, no un juicio político. Una categoría grande puede reflejar una competencia legal, una inversión excepcional, una transferencia o un límite contable distinto. La herramienta hace visibles esos patrones para que puedas volver a la fuente con una pregunta mejor definida.' },
+    { type: 'title', text: 'Qué significan los cálculos', level: 2 },
+    { type: 'paragraph', html: 'El total suma todos los importes numéricos válidos, incluidos los ajustes negativos. La parte de una categoría es su importe agrupado dividido por el total cuando este es positivo. Los importes positivos reciben barras proporcionales; los negativos permanecen en la tabla y se señalan porque representar su área como positiva cambiaría su significado.' },
+    { type: 'table', headers: ['Resultado', 'Cálculo', 'Pregunta de revisión'], rows: [['Gasto total', 'Suma de importes normalizados', '¿Todas las filas usan la misma base contable?'], ['Parte de categoría', 'Importe de categoría dividido por el total positivo', '¿Las categorías son excluyentes o una categoría padre contiene a sus hijas?'], ['Gasto por habitante', 'Total dividido por un denominador de población positivo', '¿La población describe el mismo lugar y periodo?'], ['Cambio del periodo', 'Importe actual menos anterior dividido por el valor anterior absoluto', '¿Los periodos son comparables y se evita una base cero?']] },
+    { type: 'title', text: 'Preparar datos comparables', level: 2 },
+    { type: 'paragraph', html: 'Usa una sola moneda y una definición explícita del importe en cada fila. Una autorización presupuestaria, una obligación, un pago y una previsión pueden ser cifras válidas y responder a preguntas distintas. Anota ese significado junto a la fuente porque el analizador no lo deduce del nombre de una columna.' },
+    { type: 'list', items: ['Usa una fila por categoría o indica una categoría padre para crear una jerarquía deliberada.', 'Mantén coherentes los valores de población y no mezcles residentes, electores, hogares o usuarios del servicio.', 'Incluye priorAmount solo cuando el periodo anterior use las mismas categorías y base contable.', 'Comprueba las rutas duplicadas y las filas padre para evitar dobles conteos accidentales.', 'Conserva la tabla revisada junto con el archivo original y las hipótesis usadas.'] },
+    { type: 'tip', title: 'Una proporción no es una prioridad', html: 'La categoría con mayor importe no es automáticamente la más importante, derrochadora o exitosa. Usa la vista para localizar escala y cambios, y lee después las notas de la fuente y los resultados del servicio.' },
+    { type: 'title', text: 'Leer las advertencias antes de concluir', level: 2 },
+    { type: 'paragraph', html: 'Las rutas duplicadas se agrupan para que el agregado no quede infravalorado sin avisar, pero la lista de filas de origen permite comprobar si la agrupación era intencionada. Las monedas mezcladas nunca se convierten. Una población cero elimina el gasto por habitante y un importe anterior cero elimina el porcentaje de cambio porque dividir entre cero no tiene una interpretación útil.' },
+    { type: 'paragraph', html: 'Las categorías anidadas requieren especial cuidado. Si una tabla contiene Educación y Educación > Escuelas como importes, sumarlas puede contar dos veces el mismo gasto. La herramienta avisa de las rutas anidadas, pero solo la metodología de la fuente puede decir si la categoría padre es un subtotal o una partida independiente.' },
+    { type: 'title', text: 'Qué hacer después del primer análisis', level: 2 },
+    { type: 'paragraph', html: 'Usa los números de fila para volver al archivo oficial y documentar cada corrección o interpretación. Compara datos equivalentes entre periodos, conserva los ajustes negativos como ajustes y vuelve a ejecutar el análisis después de eliminar subtotales cuando la fuente confirme que ya están incluidos.' },
+    { type: 'tip', title: 'Mantén visible el límite de los datos', html: 'Esto es un análisis descriptivo local. No verifica que el archivo esté completo, no clasifica el gasto según una norma oficial, no reconcilia monedas ni demuestra una relación causal entre gasto y resultados.' },
+  ],
+  faq: [
+    { question: '¿Qué columnas necesita el analizador?', answer: 'Cada fila necesita categoría e importe numérico. Población, periodo, priorAmount, moneda y categoría padre son opcionales.' },
+    { question: '¿Cómo se calcula el gasto por habitante?', answer: 'El total se divide por el primer valor de población positivo y consistente. Los denominadores distintos generan una advertencia.' },
+    { question: '¿Qué ocurre con las categorías duplicadas?', answer: 'Las mismas rutas de categoría se suman y sus filas de origen quedan visibles para revisarlas.' },
+    { question: '¿Puede demostrar que un presupuesto es bueno o justo?', answer: 'No. Describe los números suministrados y no puede establecer integridad, legalidad, eficiencia, justicia ni resultados.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Preparar una tabla', text: 'Crea una tabla CSV o JSON con categoría e importe por fila, usando la misma moneda y base contable.' },
+    { name: 'Añadir contexto', text: 'Añade población, periodo, priorAmount, moneda o categoría padre solo cuando mantengan un significado consistente.' },
+    { name: 'Cargar el archivo', text: 'Suelta el archivo o carga el ejemplo para ver la estructura esperada.' },
+    { name: 'Leer el paisaje', text: 'Usa las barras proporcionales para la composición y la tabla para valores, cambios y filas de origen.' },
+    { name: 'Revisar advertencias', text: 'Aclara monedas mezcladas, duplicados, ajustes negativos, denominadores cero y filas padre antes de concluir.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};