@jjlmoya/utils-civic 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-civic",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -4,11 +4,12 @@ import { electionSeatApportionmentCalculator } from '../tool/election-seat-appor
 import { referendumThresholdCalculator } from '../tool/referendum-threshold-calculator/entry';
 import { voteSeatDisproportionalityAnalyzer } from '../tool/vote-seat-disproportionality-analyzer/entry';
 import { participatoryBudgetAllocator } from '../tool/participatory-budget-allocator/entry';
+import { publicBudgetAnalyzer } from '../tool/public-budget-analyzer/entry';
 import type { CategoryLocaleContent, KnownLocale } from '../types';
 
 export const civicCategory = {
   icon: 'mdi:bank-outline',
-  tools: [civicPriorityMatrix, coalitionMajorityCalculator, electionSeatApportionmentCalculator, referendumThresholdCalculator, voteSeatDisproportionalityAnalyzer, participatoryBudgetAllocator],
+  tools: [civicPriorityMatrix, coalitionMajorityCalculator, electionSeatApportionmentCalculator, referendumThresholdCalculator, voteSeatDisproportionalityAnalyzer, participatoryBudgetAllocator, publicBudgetAnalyzer],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     de: () => import('./i18n/de').then((m) => m.content),

package/src/entries.ts

@@ -12,6 +12,7 @@ import { electionSeatApportionmentCalculator } from './tool/election-seat-apport
 import { referendumThresholdCalculator } from './tool/referendum-threshold-calculator/entry';
 import { voteSeatDisproportionalityAnalyzer } from './tool/vote-seat-disproportionality-analyzer/entry';
 import { participatoryBudgetAllocator } from './tool/participatory-budget-allocator/entry';
+import { publicBudgetAnalyzer } from './tool/public-budget-analyzer/entry';
 
 export const ALL_ENTRIES = [
   coalitionMajorityCalculator,
@@ -20,4 +21,5 @@ export const ALL_ENTRIES = [
   referendumThresholdCalculator,
   voteSeatDisproportionalityAnalyzer,
   participatoryBudgetAllocator,
+  publicBudgetAnalyzer,
 ];

package/src/tests/locale_completeness.test.ts

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

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { civicCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(6);
+      expect(ALL_TOOLS.length).toBe(7);
     });
 
     it('civicCategory should be defined', () => {

package/src/tool/public-budget-analyzer/bibliography.astro

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

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

@@ -0,0 +1,7 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  { name: 'International Monetary Fund, Government Finance Statistics Manual 2014', url: 'https://www.imf.org/external/pubs/ft/gfs/manual/2014/gfsfinal.pdf' },
+  { name: 'Intervencion General de la Administracion del Estado, Clasificacion funcional del gasto de las Administraciones Publicas COFOG', url: 'https://www.igae.pap.hacienda.gob.es/sitios/igae/es-ES/Contabilidad/ContabilidadNacional/Publicaciones/paginas/iacogof.aspx' },
+  { name: 'OECD, Budget Transparency Toolkit', url: 'https://www.oecd.org/en/publications/oecd-budget-transparency-toolkit_9789264282070-en.html' },
+];

package/src/tool/public-budget-analyzer/component.astro

@@ -0,0 +1,52 @@
+---
+import type { PublicBudgetUI } from './ui';
+
+interface Props {
+  ui: PublicBudgetUI;
+  locale?: string;
+}
+
+const { ui } = Astro.props as Props;
+---
+
+<div class="public-budget-analyzer" data-public-budget-analyzer>
+  <div class="budget-command-bar">
+    <div class="budget-dropzone" data-budget-dropzone>
+      <input id="budget-file-input" data-budget-file type="file" accept=".csv,.json,text/csv,application/json" aria-label={ui.uploadLabel} />
+      <label for="budget-file-input">{ui.uploadLabel}</label>
+      <p>{ui.uploadHelp}</p>
+      <small>{ui.supportedFormat}</small>
+    </div>
+    <div class="budget-actions">
+      <button type="button" data-budget-example aria-label={`${ui.loadExample}: ${ui.exampleName}`}>{ui.loadExample}</button>
+      <button type="button" data-budget-download>{ui.downloadCsv}</button>
+      <button type="button" data-budget-print>{ui.printAction}</button>
+    </div>
+  </div>
+  <div class="budget-result" data-budget-result aria-live="polite">
+    <p class="budget-empty-note">{ui.analyzeEmpty}</p>
+  </div>
+  <div class="budget-guidance">
+    <section>
+      <h2>{ui.methodHeading}</h2>
+      <p>{ui.methodText}</p>
+    </section>
+    <section>
+      <h2>{ui.limitsHeading}</h2>
+      <p>{ui.limitsText}</p>
+    </section>
+    <section>
+      <h2>{ui.edgeCasesHeading}</h2>
+      <p>{ui.edgeCasesText}</p>
+    </section>
+  </div>
+</div>
+
+<script is:inline type="application/json" data-budget-ui set:html={JSON.stringify(ui)}></script>
+
+<script>
+  import { mountPublicBudgetAnalyzer } from './controller';
+  const root = document.querySelector<HTMLElement>('[data-public-budget-analyzer]');
+  const data = document.querySelector<HTMLScriptElement>('[data-budget-ui]');
+  if (root && data) mountPublicBudgetAnalyzer(root, JSON.parse(data.textContent || '{}'));
+</script>

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;