@jjlmoya/utils-civic 1.2.0 → 1.3.0

package/src/tool/coalition-majority-calculator/controller.ts

@@ -0,0 +1,89 @@
+import { analyzeCoalitions, type PartyInput } from './logic';
+import { renderCoalitionResults, renderCoalitionScene, type CoalitionFilter } from './dom-views';
+import { evaluateCoalitions } from './evaluator';
+import { clearCoalitionState, loadCoalitionState, saveCoalitionState } from './storage';
+import type { CoalitionMajorityUI } from './ui';
+
+interface CoalitionConfig {
+  ui: CoalitionMajorityUI;
+}
+
+function readNumber(input: HTMLInputElement | null): number {
+  return input ? Number(input.value) : Number.NaN;
+}
+
+function partyInputs(root: HTMLElement): PartyInput[] {
+  return Array.from(root.querySelectorAll<HTMLElement>('[data-party-row]')).map((row) => ({
+    name: row.querySelector<HTMLInputElement>('[data-party-name]')?.value ?? '',
+    seats: readNumber(row.querySelector<HTMLInputElement>('[data-party-seats]')),
+  }));
+}
+
+function renderStatus(root: HTMLElement, label: string, tone: string): void {
+  const status = root.querySelector<HTMLElement>('[data-coalition-status]');
+  if (!status) return;
+  status.textContent = label;
+  status.dataset.tone = tone;
+}
+
+function createPartyRow(ui: CoalitionMajorityUI, index: number, party: PartyInput): HTMLElement {
+  const row = document.createElement('div');
+  row.className = 'party-row';
+  row.dataset.partyRow = 'true';
+  row.innerHTML = `<label><span>${ui.partyName} ${index + 1}</span><input data-party-name type="text"></label><label><span>${ui.partySeats}</span><input data-party-seats type="number" min="0" step="1"></label><button type="button" class="icon-button" data-remove-party aria-label="${ui.removeParty} ${index + 1}">x</button>`;
+  const name = row.querySelector<HTMLInputElement>('[data-party-name]');
+  const seats = row.querySelector<HTMLInputElement>('[data-party-seats]');
+  if (name) name.value = party.name;
+  if (seats) seats.value = String(party.seats);
+  return row;
+}
+
+function calculate(root: HTMLElement, ui: CoalitionMajorityUI): void {
+  const threshold = readNumber(root.querySelector<HTMLInputElement>('[data-threshold]'));
+  const analysis = analyzeCoalitions(partyInputs(root), threshold);
+  const state = evaluateCoalitions(analysis);
+  const filter = root.querySelector<HTMLSelectElement>('[data-coalition-filter]')?.value as CoalitionFilter | undefined;
+  renderStatus(root, state.label, state.tone);
+  renderCoalitionScene(root, analysis, ui);
+  renderCoalitionResults(root, analysis, ui, filter ?? 'all');
+  saveCoalitionState({ parties: analysis.parties, threshold });
+}
+
+function bindInteractions(root: HTMLElement, ui: CoalitionMajorityUI): void {
+  root.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    if (target.closest('[data-add-party]')) {
+      const rows = root.querySelector<HTMLElement>('[data-parties]');
+      const count = root.querySelectorAll('[data-party-row]').length;
+      if (rows && count < 20) rows.append(createPartyRow(ui, count, { name: '', seats: 0 }));
+      calculate(root, ui);
+    }
+    if (target.closest('[data-remove-party]')) {
+      target.closest('[data-party-row]')?.remove();
+      calculate(root, ui);
+    }
+  });
+  root.addEventListener('input', () => calculate(root, ui));
+  root.querySelector('[data-coalition-filter]')?.addEventListener('change', () => calculate(root, ui));
+  root.querySelector('[data-reset]')?.addEventListener('click', () => {
+    clearCoalitionState();
+    window.location.reload();
+  });
+}
+
+function restore(root: HTMLElement, ui: CoalitionMajorityUI): void {
+  const saved = loadCoalitionState();
+  if (!saved) return;
+  const rows = root.querySelector<HTMLElement>('[data-parties]');
+  if (!rows) return;
+  rows.innerHTML = '';
+  saved.parties.forEach((party, index) => rows.append(createPartyRow(ui, index, party)));
+  const threshold = root.querySelector<HTMLInputElement>('[data-threshold]');
+  if (threshold) threshold.value = String(saved.threshold);
+}
+
+export function mountCoalitionTool(root: HTMLElement, config: CoalitionConfig): void {
+  restore(root, config.ui);
+  bindInteractions(root, config.ui);
+  calculate(root, config.ui);
+}

package/src/tool/coalition-majority-calculator/dom-views.ts

@@ -0,0 +1,145 @@
+import type { CoalitionAnalysis, CoalitionRecord, PartyInput } from './logic';
+import type { CoalitionMajorityUI } from './ui';
+
+interface ResultTargets {
+  status: HTMLElement;
+  stats: HTMLElement;
+  pivots: HTMLElement;
+  table: HTMLTableSectionElement;
+}
+
+export type CoalitionFilter = 'all' | 'minimal' | 'surplus';
+
+interface PartyNodeLayout {
+  x: number;
+  y: number;
+  size: number;
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] ?? character);
+}
+
+function number(value: number): string {
+  return new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 }).format(value);
+}
+
+function percent(value: number): string {
+  return new Intl.NumberFormat('en-US', { style: 'percent', maximumFractionDigits: 1 }).format(value);
+}
+
+function partyNodeLayout(parties: PartyInput[]): PartyNodeLayout[] {
+  const centerX = 180;
+  const centerY = 150;
+  const radius = 104;
+  const maxSeats = Math.max(...parties.map((party) => party.seats), 1);
+  return parties.map((party, index) => {
+    const angle = -Math.PI / 2 + (index * Math.PI * 2) / parties.length;
+    const x = centerX + Math.cos(angle) * radius;
+    const y = centerY + Math.sin(angle) * radius;
+    const size = 11 + Math.sqrt(party.seats / maxSeats) * 25;
+    return { x, y, size };
+  });
+}
+
+function coalitionLinks(parties: PartyInput[], analysis: CoalitionAnalysis, layouts: PartyNodeLayout[]): string {
+  const edges = new Set<string>();
+  analysis.displayedCoalitions.filter((coalition) => coalition.minimal).forEach((coalition) => {
+    for (let left = 0; left < parties.length; left += 1) {
+      if ((coalition.mask & (1 << left)) === 0) continue;
+      for (let right = left + 1; right < parties.length; right += 1) {
+        if ((coalition.mask & (1 << right)) === 0) continue;
+        edges.add(`${left}-${right}`);
+      }
+    }
+  });
+  return [...edges].map((edge) => {
+    const indexes = edge.split('-').map(Number);
+    const left = indexes[0];
+    const right = indexes[1];
+    if (left === undefined || right === undefined) return '';
+    const start = layouts[left];
+    const end = layouts[right];
+    if (!start || !end) return '';
+    return `<line class="coalition-winning-link" x1="${start.x.toFixed(1)}" y1="${start.y.toFixed(1)}" x2="${end.x.toFixed(1)}" y2="${end.y.toFixed(1)}"/>`;
+  }).join('');
+}
+
+function partyNodes(parties: PartyInput[], analysis: CoalitionAnalysis, layouts: PartyNodeLayout[]): string {
+  const centerX = 180;
+  const centerY = 150;
+  return parties.map((party, index) => {
+    const layout = layouts[index];
+    if (!layout) return '';
+    const pivot = analysis.pivotCounts[party.name] ?? 0;
+    return `<g class="coalition-node ${pivot > 0 ? 'is-pivotal' : ''}" transform="translate(${layout.x.toFixed(1)} ${layout.y.toFixed(1)})"><line class="coalition-link" x1="${(centerX - layout.x).toFixed(1)}" y1="${(centerY - layout.y).toFixed(1)}" x2="0" y2="0"/><circle r="${layout.size.toFixed(1)}"/><text class="coalition-node-name" y="-3">${escapeHtml(party.name)}</text><text class="coalition-node-seats" y="12">${number(party.seats)} seats</text></g>`;
+  }).join('');
+}
+
+export function renderCoalitionScene(root: HTMLElement, analysis: CoalitionAnalysis, ui: CoalitionMajorityUI): void {
+  const scene = root.querySelector<HTMLElement>('[data-coalition-scene]');
+  if (!scene) return;
+  if (!analysis.valid || analysis.parties.length === 0) {
+    scene.innerHTML = `<div class="scene-empty">${escapeHtml(ui.emptyState)}</div>`;
+    return;
+  }
+  const layouts = partyNodeLayout(analysis.parties);
+  scene.innerHTML = `<svg viewBox="0 0 360 300" role="img" aria-label="${escapeHtml(ui.coalitionSceneLabel)}"><circle class="coalition-orbit" cx="180" cy="150" r="58"/><g class="coalition-winning-links" aria-hidden="true">${coalitionLinks(analysis.parties, analysis, layouts)}</g><circle class="coalition-core" cx="180" cy="150" r="42"/><text class="coalition-core-label" x="180" y="146" text-anchor="middle">${number(analysis.threshold)}</text><text class="coalition-core-caption" x="180" y="163" text-anchor="middle">${escapeHtml(ui.threshold.toLowerCase())}</text>${partyNodes(analysis.parties, analysis, layouts)}</svg>`;
+}
+
+function stat(label: string, value: string): string {
+  return `<div class="coalition-stat"><dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd></div>`;
+}
+
+function coalitionRow(row: CoalitionRecord, ui: CoalitionMajorityUI): string {
+  const members = row.members.map(escapeHtml).join(', ');
+  const redundant = row.redundantMembers.length === 0 ? ui.none : row.redundantMembers.map(escapeHtml).join(', ');
+  const label = row.minimal ? ui.minimalCoalition : ui.surplusCoalition;
+  return `<tr><th scope="row"><span class="row-badge ${row.minimal ? 'is-minimal' : ''}">${escapeHtml(label)}</span><span>${members}</span></th><td>${number(row.seats)}</td><td>+${number(row.surplus)}</td><td>${redundant}</td></tr>`;
+}
+
+function renderPivots(analysis: CoalitionAnalysis, ui: CoalitionMajorityUI): string {
+  return analysis.parties.map((party) => {
+    const count = analysis.pivotCounts[party.name] ?? 0;
+    const share = analysis.pivotShares[party.name] ?? 0;
+    return `<li><span>${escapeHtml(party.name)}</span><strong>${number(count)}</strong><small>${percent(share)} ${escapeHtml(ui.pivotal)}</small></li>`;
+  }).join('');
+}
+
+function filterRows(rows: CoalitionRecord[], filter: CoalitionFilter): CoalitionRecord[] {
+  if (filter === 'minimal') return rows.filter((row) => row.minimal);
+  if (filter === 'surplus') return rows.filter((row) => !row.minimal);
+  return rows;
+}
+
+function clearResults(targets: ResultTargets, label: string): void {
+  targets.status.textContent = label;
+  targets.stats.innerHTML = '';
+  targets.pivots.innerHTML = '';
+  targets.table.innerHTML = '';
+}
+
+function resultLabel(analysis: CoalitionAnalysis, ui: CoalitionMajorityUI): string {
+  if (analysis.warnings[0]) return analysis.warnings[0];
+  if (analysis.winningCoalitions > 0) return `${number(analysis.winningCoalitions)} ${ui.winningCoalitions.toLowerCase()}`;
+  return ui.noPivots;
+}
+
+function getResultTargets(root: HTMLElement): ResultTargets | undefined {
+  const status = root.querySelector<HTMLElement>('[data-coalition-status]');
+  const stats = root.querySelector<HTMLElement>('[data-coalition-stats]');
+  const pivots = root.querySelector<HTMLElement>('[data-coalition-pivots]');
+  const table = root.querySelector<HTMLTableSectionElement>('[data-coalition-rows]');
+  return status && stats && pivots && table ? { status, stats, pivots, table } : undefined;
+}
+
+export function renderCoalitionResults(root: HTMLElement, analysis: CoalitionAnalysis, ui: CoalitionMajorityUI, filter: CoalitionFilter = 'all'): void {
+  const targets = getResultTargets(root);
+  if (!targets) return;
+  if (!analysis.valid) return clearResults(targets, analysis.error ?? 'Check the inputs.');
+  targets.status.textContent = resultLabel(analysis, ui);
+  targets.stats.innerHTML = [stat(ui.chamberSeats, number(analysis.totalSeats)), stat(ui.threshold, number(analysis.threshold)), stat(ui.totalCoalitions, number(analysis.totalCoalitions)), stat(ui.minimalCoalition, number(analysis.minimalWinningCoalitions)), stat(ui.criticalDefections, number(analysis.pivotTotal))].join('');
+  targets.pivots.innerHTML = renderPivots(analysis, ui);
+  const rows = filterRows(analysis.displayedCoalitions, filter);
+  targets.table.innerHTML = rows.length === 0 ? `<tr><td colspan="4">${escapeHtml(ui.noMatchingCoalitions)}</td></tr>` : rows.map((row) => coalitionRow(row, ui)).join('');
+}

package/src/tool/coalition-majority-calculator/entry.ts

@@ -0,0 +1,28 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { CoalitionMajorityUI } from './ui';
+
+export type { CoalitionMajorityUI } from './ui';
+export type CoalitionMajorityLocaleContent = ToolLocaleContent<CoalitionMajorityUI>;
+
+export const coalitionMajorityCalculator: CivicToolEntry<CoalitionMajorityUI> = {
+  id: 'coalition-majority-calculator',
+  phase: 'localized',
+  icons: { bg: 'mdi:bank', fg: 'mdi:account-group' },
+  i18n: {
+    en: () => import('./i18n/en').then((module) => module.content),
+    de: () => import('./i18n/de').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/coalition-majority-calculator/evaluator.ts

@@ -0,0 +1,13 @@
+import type { CoalitionAnalysis } from './logic';
+
+export interface CoalitionStatus {
+  tone: 'good' | 'warn' | 'neutral';
+  label: string;
+}
+
+export function evaluateCoalitions(analysis: CoalitionAnalysis): CoalitionStatus {
+  if (!analysis.valid) return { tone: 'warn', label: analysis.error ?? 'Check the inputs.' };
+  if (analysis.winningCoalitions === 0) return { tone: 'warn', label: 'No winning coalition exists.' };
+  if (analysis.minimalWinningCoalitions === 0) return { tone: 'neutral', label: 'Winning coalitions exist, but none is minimal.' };
+  return { tone: 'good', label: `${analysis.minimalWinningCoalitions} minimal winning coalition${analysis.minimalWinningCoalitions === 1 ? '' : 's'} found.` };
+}

package/src/tool/coalition-majority-calculator/i18n/de.ts

@@ -0,0 +1,51 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CoalitionMajorityLocaleContent } from '../entry';
+import type { CoalitionMajorityUI } from '../ui';
+
+const ui: CoalitionMajorityUI = {
+  addParty: 'Partei hinzufügen', allCoalitions: 'Alle siegreichen Koalitionen', calculate: 'Koalitionen berechnen', chamberSeats: 'Sitze insgesamt', coalitionSceneLabel: 'Koalitionskonstellation', criticalDefections: 'Kritische Austritte', emptyState: 'Füge mindestens zwei Parteien hinzu und trage ihre Sitze ein.', explanation: 'Das Modell nimmt an, dass jede aufgeführte Partei jeder Kombination beitreten kann. Es misst Sitzarithmetik, nicht politische Vereinbarkeit.', edgeCasesText: 'Leere oder doppelte Namen werden eindeutig gemacht. Parteien mit null Sitzen können nie entscheidend sein. Über 20 Parteien wird die exakte Suche beendet.', edgeCasesTitle: 'Grenzfälle und Warnungen', filterCoalitions: 'Anzeigen', maximumParties: 'Maximal 20 Parteien, weil die vollständige Aufzählung mit 2 hoch N wächst.', majorityThreshold: 'Mehrheitsschwelle', methodTitle: 'Angewandtes Modell', methodText: 'Jede nicht leere Teilmenge wird geprüft. Eine Koalition gewinnt ab der angegebenen Schwelle. Eine Partei ist entscheidend, wenn ihr Austritt eine gewinnende Koalition verlieren lässt.', minimalCoalition: 'Minimale Gewinnkoalition', noMatchingCoalitions: 'Keine Koalition passt zu diesem Filter.', noPivots: 'Unter dieser Schwelle ist keine Partei entscheidend.', none: 'Keine', notDoText: 'Das Modell bewertet weder Ideologie, politische Vereinbarkeit, Verhandlungen, Legitimität, Stabilität noch die Wahrscheinlichkeit einer Regierungsbildung.', notDoTitle: 'Was dieses Tool nicht leistet', partyName: 'Parteiname', partySeats: 'Sitze', partyTable: 'Koalitionsdetails', pivotal: 'entscheidend', pivotalParty: 'Entscheidende Partei', redundantMembers: 'Überflüssige Mitglieder', removeParty: 'Partei entfernen', reset: 'Beispiel zurücksetzen', resultTitle: 'Koalitionskarte', seats: 'Sitze', surplus: 'Überschuss', surplusCoalition: 'Koalition mit Überschuss', threshold: 'Schwelle', thresholdHint: 'Eine Koalition gewinnt, sobald ihre Sitze diese Schwelle erreichen oder überschreiten.', totalCoalitions: 'Mögliche nicht leere Koalitionen', winningCoalitions: 'Gewinnende Koalitionen',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Rechner für Koalitionsmehrheiten', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Sitzbasierte Koalitionen, minimale Gewinnkoalitionen und entscheidende Parteien unter einer festgelegten Schwelle auflisten.', url: 'https://gamebob.dev/de/koalitionsmehrheit-rechner', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Wann ist eine Koalition minimal?', acceptedAnswer: { '@type': 'Answer', text: 'Sie ist minimal, wenn der Austritt jedes einzelnen Mitglieds die Koalition unter die festgelegte Sitzschwelle bringt. Eine Koalition mit Überschuss bleibt auch nach dem Austritt mindestens eines Mitglieds siegreich.' } },
+  { '@type': 'Question', name: 'Was bedeutet entscheidend?', acceptedAnswer: { '@type': 'Answer', text: 'Eine Partei wird jedes Mal als entscheidend gezählt, wenn ihr Austritt eine bestimmte gewinnende Koalition in eine verlierende Koalition verwandelt. Ihr Anteil wird durch alle kritischen Austritte geteilt.' } },
+  { '@type': 'Question', name: 'Sagt der Rechner eine echte Regierung voraus?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Er bewertet nur erklärte Sitzgewichte und eine Schwelle. Ideologie, Verhandlungen, Minderheitsunterstützung und Verfassungsregeln liegen außerhalb des Modells.' } },
+  { '@type': 'Question', name: 'Warum gibt es eine Grenze von 20 Parteien?', acceptedAnswer: { '@type': 'Answer', text: 'Das Tool prüft jede nicht leere Teilmenge. Bei 20 Parteien entstehen bereits 1.048.575 Kombinationen, was eine praktikable Grenze im Browser ist.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Eine gewichtete Mehrheitskoalition untersuchen', step: [
+  { '@type': 'HowToStep', name: 'Parteien eingeben', text: 'Füge jede Partei hinzu und trage ihr Sitzgewicht ein. Eindeutige Namen erleichtern die Prüfung.' },
+  { '@type': 'HowToStep', name: 'Schwelle festlegen', text: 'Gib die Sitzzahl ein, die eine Koalition erreichen muss.' },
+  { '@type': 'HowToStep', name: 'Konstellation prüfen', text: 'Achte auf Parteien mit Akzentring und vergleiche ihre entscheidenden Zählungen mit ihrer Sitzzahl.' },
+  { '@type': 'HowToStep', name: 'Tabelle lesen', text: 'Vergleiche minimale Gewinnkoalitionen, Überschuss, und überflüssige Mitglieder.' },
+  { '@type': 'HowToStep', name: 'Szenario verändern', text: 'Ändere jeweils nur eine Sitzzahl oder die Schwelle, damit die Ursache neuer Koalitionen sichtbar bleibt.' },
+] };
+
+export const content: CoalitionMajorityLocaleContent = { slug: 'koalitionsmehrheit-rechner', title: 'Rechner für Koalitionsmehrheiten', description: 'Untersuche jede sitzbasierte Koalition unter einer festgelegten Mehrheitsschwelle und finde minimale Gewinnkoalitionen sowie entscheidende Parteien.', ui, seo: [
+  { type: 'title', text: 'Welche Sitzkombinationen eine Mehrheit erreichen', level: 2 },
+  { type: 'paragraph', html: 'Eine Koalition gewinnt, wenn die Sitze ihrer Mitglieder mindestens die von dir festgelegte Schwelle erreichen. Dieser Rechner prüft jede nicht leere Kombination und zeigt den genauen Überschuss. So lässt sich nachvollziehen, warum eine Gruppe gewinnt.' },
+  { type: 'title', text: 'Minimale Koalitionen und Koalitionen mit Überschuss', level: 2 },
+  { type: 'paragraph', html: 'Eine minimale Gewinnkoalition verliert ihre Mehrheit, sobald ein beliebiges Mitglied austritt. Eine Koalition mit Überschuss bleibt nach dem Austritt eines oder mehrerer Mitglieder siegreich. Das ist eine strukturelle Aussage über Sitze, keine Vorhersage politischer Stabilität.' },
+  { type: 'table', headers: ['Ergebnis', 'Prüfung', 'Erkenntnis'], rows: [['Gewinnende Koalition', 'Die Sitze erreichen die Schwelle.', 'Welche Gruppen rechnerisch gewinnen können.'], ['Minimale Gewinnkoalition', 'Jedes Mitglied ist für den Sieg entscheidend.', 'Welche Gruppe keinen Sitzüberschuss hat.'], ['Koalition mit Überschuss', 'Mindestens ein Mitglied kann ausscheiden und die Gruppe gewinnt weiter.', 'Wo eine Mehrheit redundante Partner hat.']] },
+  { type: 'title', text: 'Entscheidende Parteien als Sitzarithmetik lesen', level: 2 },
+  { type: 'paragraph', html: 'Die entscheidende Zählung folgt einer Banzhaf-artigen kritischen Austrittsprüfung. Eine Partei zählt, wenn ihr Austritt eine bestimmte gewinnende Koalition verlieren lässt. Der Anteil wird über alle kritischen Austritte normalisiert.' },
+  { type: 'list', items: ['Beginne mit der Gesamtzahl der Sitze und verwende die Schwelle deiner Regel.', 'Halte die Schwelle fest, wenn du zwei Sitzverteilungen vergleichst.', 'Prüfe überflüssige Mitglieder in der Tabelle, bevor du die Liste entscheidender Parteien deutest.', 'Ändere beim Sensitivitätstest jeweils nur eine Partei.', 'Behandle null Sitze und doppelte Namen als Datenprobleme, nicht als politische Aussagen.'] },
+  { type: 'title', text: 'Eine begrenzte exakte Suche', level: 2 },
+  { type: 'paragraph', html: 'Bei N Parteien bewertet der Rechner 2 hoch N minus 1 nicht leere Koalitionen. Die Grenze von 20 Parteien hält die vollständige Suche im Browser nachvollziehbar. Die Tabelle zeigt eine lesbare Auswahl, während die Summen die gesamte Suche umfassen.' },
+  { type: 'tip', title: 'Schwellen sind Annahmen, keine Gesetze', html: 'Der Rechner erkennt keine landesspezifische Mehrheit, Investiturregel oder Vertrauensvereinbarung. Gib die Schwelle selbst an und bewahre die Regel neben dem Ergebnis auf.' },
+  { type: 'title', text: 'Was das Modell nicht ableiten kann', level: 2 },
+  { type: 'paragraph', html: 'Sitzgewichte beschreiben nur die Fähigkeit einer Gruppe, eine Zahlenschwelle zu überschreiten. Das Modell bewertet keine Ideologie, politische Distanz, Kabinettsverhandlungen, Legitimität, Stabilität oder Überlebenswahrscheinlichkeit einer Regierung.' },
+  { type: 'tip', title: 'Nutze das Ergebnis als Prüfspur', html: 'Wenn eine Partei entscheidend ist, suche eine gewinnende Koalition, in der ihr Austritt die Schwelle unterschreitet. Bei Überschusskoalitionen zeigen die überflüssigen Mitglieder, wo Sitzreserven liegen.' },
+], faq: [
+  { question: 'Wann ist eine Koalition minimal?', answer: 'Wenn der Austritt jedes Mitglieds sie verlieren lässt. Kann mindestens ein Mitglied austreten und die Schwelle bleibt erreicht, handelt es sich um eine Koalition mit Überschuss.' },
+  { question: 'Was bedeutet entscheidend?', answer: 'Eine Partei ist für jede gewinnende Koalition entscheidend, die ohne sie verliert. Ihr Anteil ist ihre kritische Zählung geteilt durch die Gesamtzahl kritischer Austritte.' },
+  { question: 'Sagt das eine echte Regierung voraus?', answer: 'Nein. Der Rechner bewertet nur Sitzarithmetik. Politische Vereinbarkeit, Verhandlungen und Verfassungsregeln gehören nicht zum Modell.' },
+  { question: 'Warum sind es höchstens 20 Parteien?', answer: 'Die exakte Suche prüft 2 hoch N minus 1 Kombinationen. Bei 20 Parteien sind das bereits 1.048.575 Kombinationen.' },
+], bibliography, howTo: [
+  { name: 'Parteien eingeben', text: 'Füge jede Partei hinzu und trage ihr Sitzgewicht mit einem eindeutigen Namen ein.' },
+  { name: 'Schwelle festlegen', text: 'Gib die Sitzzahl ein, die eine Koalition zum Sieg benötigt.' },
+  { name: 'Entscheidende Parteien prüfen', text: 'Nutze Akzentringe und Zählungen, um notwendige Parteien zu erkennen.' },
+  { name: 'Tabelle lesen', text: 'Vergleiche minimale Gruppen, Überschuss und überflüssige Mitglieder.' },
+  { name: 'Eine Annahme ändern', text: 'Passe jeweils nur eine Sitzzahl oder die Schwelle an.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/coalition-majority-calculator/i18n/en.ts

@@ -0,0 +1,74 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CoalitionMajorityLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Coalition Majority Calculator',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Enumerate seat based coalitions, minimal winning groups, and pivotal parties under a declared threshold.',
+  url: 'https://gamebob.dev/en/coalition-majority-calculator',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What makes a coalition minimal?', acceptedAnswer: { '@type': 'Answer', text: 'A winning coalition is minimal when removing any one of its members makes the coalition fall below the declared seat threshold. A surplus coalition still wins after at least one member leaves.' } },
+    { '@type': 'Question', name: 'What does pivotal mean here?', acceptedAnswer: { '@type': 'Answer', text: 'A party is counted as pivotal each time it belongs to a winning coalition that would become losing without it. The displayed share is its count divided by all such critical defections.' } },
+    { '@type': 'Question', name: 'Does the calculator predict a real government?', acceptedAnswer: { '@type': 'Answer', text: 'No. It only evaluates declared seat weights and a threshold. It does not know ideology, policy compatibility, bargaining, confidence agreements, minority support, or constitutional rules.' } },
+    { '@type': 'Question', name: 'Why is there a limit of 20 parties?', acceptedAnswer: { '@type': 'Answer', text: 'The tool checks every non empty subset, so the number of possible coalitions is 2 to the power of N minus 1. Twenty parties already create 1,048,575 non empty combinations, which is a practical browser boundary.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Explore a weighted majority coalition',
+  step: [
+    { '@type': 'HowToStep', name: 'Enter the parties', text: 'Add each party and enter its seat weight. Keep names distinct so the result remains easy to audit.' },
+    { '@type': 'HowToStep', name: 'Set the threshold', text: 'Enter the number of seats a coalition must reach. The threshold is visible again in the result.' },
+    { '@type': 'HowToStep', name: 'Inspect the constellation', text: 'Look for parties with an accent ring and compare their pivotal counts with their seat totals.' },
+    { '@type': 'HowToStep', name: 'Read the coalition table', text: 'Compare minimal winning coalitions with surplus coalitions, their seat surplus, and their redundant members.' },
+    { '@type': 'HowToStep', name: 'Test another scenario', text: 'Change one seat total or the threshold at a time to see which coalitions appear or disappear.' },
+  ],
+};
+
+export const content: CoalitionMajorityLocaleContent = {
+  slug: 'coalition-majority-calculator',
+  title: 'Coalition Majority Calculator',
+  description: 'Explore every seat based coalition under a declared majority threshold. Find minimal winning groups, surplus seats, and parties that are pivotal in the arithmetic.',
+  ui,
+  seo: [
+    { type: 'title', text: 'See Which Seat Combinations Can Reach a Majority', level: 2 },
+    { type: 'paragraph', html: 'A coalition is winning when the seats held by its members meet or exceed the threshold you declare. This calculator enumerates each non empty combination of parties, reports the groups that can win, and shows the exact surplus above the threshold. Because the result is built from explicit seat weights, you can inspect why a group wins instead of relying on a vague ranking.' },
+    { type: 'title', text: 'Minimal Winning and Surplus Coalitions', level: 2 },
+    { type: 'paragraph', html: 'A minimal winning coalition loses its majority when any one member leaves. A surplus coalition remains above the threshold after one or more members leave, so it contains redundancy under this seat rule. The distinction is structural: it does not say that a party would actually leave or that a minimal coalition would be politically stable.' },
+    { type: 'table', headers: ['Result', 'Test applied', 'What it helps you see'], rows: [['Winning coalition', 'Member seats are at least the threshold.', 'Which groups have enough seats in principle.'], ['Minimal winning coalition', 'Every member is critical to staying above the threshold.', 'Which groups have no seat arithmetic surplus.'], ['Surplus coalition', 'At least one member can be removed and the group still wins.', 'Where a majority has redundant partners.']] },
+    { type: 'title', text: 'Read Pivotal Parties as Seat Arithmetic', level: 2 },
+    { type: 'paragraph', html: 'The pivotal count uses a Banzhaf style critical defection: a party is counted when removing it changes a particular winning coalition into a losing one. The share is normalized across all critical defections in the scenario. A party can therefore have more pivotal influence than its seat share suggests, while another party can hold seats without ever being necessary in a winning group.' },
+    { type: 'list', items: ['Start with the chamber seat total and use the threshold that matches your declared rule.', 'Keep the same threshold while comparing two seat distributions.', 'Use the coalition table to inspect redundant members before drawing conclusions from the pivot list.', 'Change one party at a time when exploring sensitivity so the cause of a new coalition remains visible.', 'Treat zero seat parties and duplicated labels as data quality issues, not as political conclusions.'] },
+    { type: 'title', text: 'A Bounded Exact Search', level: 2 },
+    { type: 'paragraph', html: 'For N parties, the calculator evaluates 2 to the power of N minus 1 non empty coalitions. The limit of 20 parties keeps exhaustive enumeration transparent and usable in a browser. The table shows a readable subset of the winning groups while the summary counts are calculated over the complete search.' },
+    { type: 'tip', title: 'Thresholds are assumptions, not laws', html: 'The calculator does not identify a country rule, an investiture requirement, a confidence agreement, or a valid parliamentary majority. Enter the threshold yourself and preserve the rule beside any saved result. Real coalition formation also depends on preferences, negotiation, institutions, and support from outside the listed group.' },
+    { type: 'title', text: 'What the Model Cannot Infer', level: 2 },
+    { type: 'paragraph', html: 'Seat weights describe the capacity of a group to cross a numerical threshold, not the likelihood that parties will cooperate. The model does not assess ideology, policy distance, cabinet bargaining, discipline, legitimacy, stability, or the probability of a government surviving. It also does not account for absent members, internal factions, constitutional exceptions, or votes that require a different quorum.' },
+    { type: 'tip', title: 'Use the result as an audit trail', html: 'When a party is marked pivotal, find one of the listed winning coalitions where its removal crosses the threshold. When a coalition is marked surplus, inspect its redundant members. These checks make the arithmetic reproducible without turning it into a forecast.' },
+  ],
+  faq: [
+    { question: 'What makes a coalition minimal?', answer: 'A winning coalition is minimal when removing any one member makes it lose. If at least one member can leave while the coalition still reaches the threshold, it is surplus.' },
+    { question: 'What does pivotal mean here?', answer: 'A party is pivotal for every winning coalition that becomes losing when that party is removed. The share is its critical count divided by the total critical count.' },
+    { question: 'Does this predict a real government?', answer: 'No. It evaluates seat arithmetic only. Political compatibility, bargaining, minority support, constitutional rules, and confidence agreements are outside the model.' },
+    { question: 'Why is the limit 20 parties?', answer: 'The exact search checks 2 to the power of N minus 1 non empty combinations. Twenty parties already produce 1,048,575 combinations.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Enter the parties', text: 'Add each party and enter its seat weight with a distinct name.' },
+    { name: 'Set the threshold', text: 'Enter the number of seats needed for a coalition to win.' },
+    { name: 'Inspect pivotal parties', text: 'Use the accent rings and pivotal counts to identify parties that are necessary in winning groups.' },
+    { name: 'Read the table', text: 'Compare minimal winning groups with surplus groups and their redundant members.' },
+    { name: 'Change one assumption', text: 'Adjust one seat total or the threshold at a time to keep the scenario interpretable.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};

package/src/tool/coalition-majority-calculator/i18n/es.ts

@@ -0,0 +1,51 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CoalitionMajorityLocaleContent } from '../entry';
+import type { CoalitionMajorityUI } from '../ui';
+
+const ui: CoalitionMajorityUI = {
+  addParty: 'Añadir partido', allCoalitions: 'Todas las coaliciones ganadoras', calculate: 'Calcular coaliciones', chamberSeats: 'Escaños totales', coalitionSceneLabel: 'Constelación de coaliciones', criticalDefections: 'Salidas críticas', emptyState: 'Añade al menos dos partidos e introduce sus escaños.', explanation: 'El modelo supone que cada partido puede unirse a cualquier combinación. Mide aritmética de escaños, no compatibilidad política.', edgeCasesText: 'Los nombres vacíos o duplicados se hacen únicos. Un partido con cero escaños nunca puede ser decisivo. Con más de 20 partidos se detiene la búsqueda exacta.', edgeCasesTitle: 'Casos límite y avisos', filterCoalitions: 'Mostrar', maximumParties: 'Máximo 20 partidos porque la enumeración exhaustiva crece como 2 elevado a N.', majorityThreshold: 'Umbral de mayoría', methodTitle: 'Modelo aplicado', methodText: 'Se comprueba cada subconjunto no vacío. Una coalición gana al alcanzar el umbral declarado. Un partido es decisivo si al retirarlo una coalición ganadora pierde.', minimalCoalition: 'Coalición mínima ganadora', noMatchingCoalitions: 'Ninguna coalición coincide con este filtro.', noPivots: 'Ningún partido es decisivo con este umbral.', none: 'Ninguno', notDoText: 'No evalúa ideología, compatibilidad política, negociación, legitimidad, estabilidad ni si llegará a formarse un gobierno.', notDoTitle: 'Lo que no hace esta herramienta', partyName: 'Nombre del partido', partySeats: 'Escaños', partyTable: 'Detalles de coalición', pivotal: 'decisivo', pivotalParty: 'Partido decisivo', redundantMembers: 'Miembros redundantes', removeParty: 'Eliminar partido', reset: 'Restablecer ejemplo', resultTitle: 'Mapa de coaliciones', seats: 'escaños', surplus: 'excedente', surplusCoalition: 'Coalición con excedente', threshold: 'Umbral', thresholdHint: 'Una coalición gana cuando sus escaños alcanzan o superan este umbral.', totalCoalitions: 'Coaliciones no vacías posibles', winningCoalitions: 'Coaliciones ganadoras',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Calculadora de mayoría de coaliciones', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Enumera coaliciones por escaños, coaliciones mínimas ganadoras y partidos decisivos bajo un umbral declarado.', url: 'https://gamebob.dev/es/calculadora-mayoria-coaliciones', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: '¿Cuándo es mínima una coalición?', acceptedAnswer: { '@type': 'Answer', text: 'Es mínima cuando retirar a cualquiera de sus miembros hace que baje del umbral de escaños declarado. Una coalición con excedente sigue ganando aunque se retire al menos un miembro.' } },
+  { '@type': 'Question', name: '¿Qué significa decisivo?', acceptedAnswer: { '@type': 'Answer', text: 'Un partido se cuenta como decisivo cada vez que retirarlo convierte una coalición ganadora en perdedora. Su porcentaje divide su cuenta entre todas las salidas críticas.' } },
+  { '@type': 'Question', name: '¿La calculadora predice un gobierno real?', acceptedAnswer: { '@type': 'Answer', text: 'No. Solo evalúa pesos de escaños y un umbral declarados. La ideología, la negociación, el apoyo minoritario y las reglas constitucionales quedan fuera.' } },
+  { '@type': 'Question', name: '¿Por qué hay un límite de 20 partidos?', acceptedAnswer: { '@type': 'Answer', text: 'La herramienta comprueba cada subconjunto no vacío. Veinte partidos ya producen 1.048.575 combinaciones, un límite práctico para el navegador.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Explorar una mayoría ponderada', step: [
+  { '@type': 'HowToStep', name: 'Introduce los partidos', text: 'Añade cada partido e indica sus escaños. Usa nombres distintos para auditar el resultado.' },
+  { '@type': 'HowToStep', name: 'Fija el umbral', text: 'Escribe cuántos escaños debe alcanzar una coalición para ganar.' },
+  { '@type': 'HowToStep', name: 'Mira la constelación', text: 'Observa los anillos de acento y compara el recuento decisivo con los escaños.' },
+  { '@type': 'HowToStep', name: 'Lee la tabla', text: 'Compara coaliciones mínimas, excedente y miembros redundantes.' },
+  { '@type': 'HowToStep', name: 'Prueba otro escenario', text: 'Cambia un escaño o el umbral cada vez para entender qué coaliciones aparecen.' },
+] };
+
+export const content: CoalitionMajorityLocaleContent = { slug: 'calculadora-mayoria-coaliciones', title: 'Calculadora de mayoría de coaliciones', description: 'Explora cada coalición por escaños con un umbral de mayoría declarado. Encuentra grupos mínimos ganadores, excedente y partidos decisivos.', ui, seo: [
+  { type: 'title', text: 'Qué combinaciones de escaños alcanzan una mayoría', level: 2 },
+  { type: 'paragraph', html: 'Una coalición gana cuando los escaños de sus miembros alcanzan o superan el umbral que declaras. Esta calculadora enumera cada combinación no vacía y muestra el excedente exacto sobre el umbral. Así puedes revisar por qué gana un grupo.' },
+  { type: 'title', text: 'Coaliciones mínimas y coaliciones con excedente', level: 2 },
+  { type: 'paragraph', html: 'Una coalición mínima ganadora pierde la mayoría si se marcha cualquier miembro. Una coalición con excedente sigue por encima del umbral aunque se retire uno o más miembros. Es una distinción estructural de escaños, no una predicción de estabilidad política.' },
+  { type: 'table', headers: ['Resultado', 'Prueba aplicada', 'Qué permite ver'], rows: [['Coalición ganadora', 'Sus escaños alcanzan el umbral.', 'Qué grupos tienen escaños suficientes en principio.'], ['Coalición mínima ganadora', 'Cada miembro es necesario para seguir ganando.', 'Qué grupos no tienen excedente aritmético.'], ['Coalición con excedente', 'Se puede retirar al menos un miembro y sigue ganando.', 'Dónde una mayoría tiene socios redundantes.']] },
+  { type: 'title', text: 'Leer los partidos decisivos como aritmética', level: 2 },
+  { type: 'paragraph', html: 'El recuento decisivo usa una prueba de salida crítica inspirada en Banzhaf: un partido cuenta cuando retirarlo convierte una coalición ganadora en perdedora. El porcentaje se normaliza entre todas las salidas críticas del escenario.' },
+  { type: 'list', items: ['Empieza con el total de escaños y usa el umbral de tu regla.', 'Mantén el mismo umbral al comparar dos repartos de escaños.', 'Mira los miembros redundantes en la tabla antes de interpretar la lista decisiva.', 'Cambia un partido cada vez para entender la sensibilidad del resultado.', 'Trata los nombres duplicados y los partidos sin escaños como problemas de datos.'] },
+  { type: 'title', text: 'Una búsqueda exacta con límite', level: 2 },
+  { type: 'paragraph', html: 'Para N partidos, la calculadora evalúa 2 elevado a N menos 1 coaliciones no vacías. El límite de 20 mantiene la búsqueda exhaustiva comprensible y usable en el navegador. La tabla muestra un subconjunto legible y los totales cubren toda la búsqueda.' },
+  { type: 'tip', title: 'Los umbrales son supuestos, no leyes', html: 'La calculadora no identifica una regla constitucional, una investidura ni una mayoría parlamentaria válida. Introduce el umbral y conserva esa regla junto al resultado.' },
+  { type: 'title', text: 'Lo que el modelo no puede inferir', level: 2 },
+  { type: 'paragraph', html: 'Los escaños describen la capacidad de cruzar una cifra, no la probabilidad de cooperar. El modelo no valora ideología, distancia programática, negociación, legitimidad, estabilidad, facciones internas ni apoyo externo.' },
+  { type: 'tip', title: 'Usa el resultado como rastro de auditoría', html: 'Cuando un partido aparece como decisivo, localiza una coalición ganadora donde su salida cruce el umbral. Cuando una coalición tiene excedente, revisa sus miembros redundantes.' },
+], faq: [
+  { question: '¿Cuándo es mínima una coalición?', answer: 'Cuando retirar a cualquiera de sus miembros hace que pierda. Si al menos uno puede salir y todavía alcanza el umbral, tiene excedente.' },
+  { question: '¿Qué significa decisivo?', answer: 'Un partido es decisivo en cada coalición ganadora que se vuelve perdedora al retirarlo. Su porcentaje es su cuenta crítica dividida por el total crítico.' },
+  { question: '¿Predice un gobierno real?', answer: 'No. Solo evalúa aritmética de escaños. La compatibilidad política, la negociación y las reglas constitucionales quedan fuera.' },
+  { question: '¿Por qué el límite es 20 partidos?', answer: 'La búsqueda exacta revisa 2 elevado a N menos 1 combinaciones. Con 20 partidos ya son 1.048.575.' },
+], bibliography, howTo: [
+  { name: 'Introduce los partidos', text: 'Añade cada partido con sus escaños y un nombre distinto.' },
+  { name: 'Fija el umbral', text: 'Indica cuántos escaños necesita una coalición para ganar.' },
+  { name: 'Revisa los decisivos', text: 'Usa los anillos y los recuentos para identificar partidos necesarios.' },
+  { name: 'Lee la tabla', text: 'Compara grupos mínimos, excedente y miembros redundantes.' },
+  { name: 'Cambia un supuesto', text: 'Ajusta un escaño o el umbral cada vez.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/coalition-majority-calculator/i18n/fr.ts

@@ -0,0 +1,12 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CoalitionMajorityLocaleContent } from '../entry';
+import type { CoalitionMajorityUI } from '../ui';
+
+const ui: CoalitionMajorityUI = {
+  addParty: `Ajouter un parti`, allCoalitions: `Toutes les coalitions gagnantes`, calculate: `Calculer les coalitions`, chamberSeats: `Sièges totaux`, coalitionSceneLabel: `Constellation des coalitions`, criticalDefections: `Défections critiques`, emptyState: `Ajoutez au moins deux partis et saisissez leurs sièges.`, explanation: `Le modèle suppose que chaque parti peut rejoindre toute combinaison. Il mesure l'arithmétique des sièges, pas la compatibilité politique.`, edgeCasesText: `Les noms vides ou doublons sont rendus uniques. Un parti sans siège ne peut jamais être décisif. Au-delà de 20 partis, la recherche exacte s'arrête.`, edgeCasesTitle: `Cas limites et avertissements`, filterCoalitions: `Afficher`, maximumParties: `Vingt partis maximum, car l'énumération exhaustive croît comme 2 puissance N.`, majorityThreshold: `Seuil de majorité`, methodTitle: `Modèle appliqué`, methodText: `Chaque sous-ensemble non vide est vérifié. Une coalition gagne lorsqu'elle atteint le seuil déclaré. Un parti est décisif si son départ fait perdre une coalition gagnante.`, minimalCoalition: `Coalition gagnante minimale`, noMatchingCoalitions: `Aucune coalition ne correspond à ce filtre.`, noPivots: `Aucun parti n'est décisif avec ce seuil.`, none: `Aucun`, notDoText: `L'outil n'évalue ni l'idéologie, ni la compatibilité politique, ni la négociation, ni la légitimité, ni la stabilité, ni la probabilité de former un gouvernement.`, notDoTitle: `Ce que cet outil ne fait pas`, partyName: `Nom du parti`, partySeats: `Sièges`, partyTable: `Détails de la coalition`, pivotal: `décisif`, pivotalParty: `Parti décisif`, redundantMembers: `Membres redondants`, removeParty: `Supprimer le parti`, reset: `Réinitialiser l'exemple`, resultTitle: `Carte des coalitions`, seats: `sièges`, surplus: `excédent`, surplusCoalition: `Coalition excédentaire`, threshold: `Seuil`, thresholdHint: `Une coalition gagne lorsque ses sièges atteignent ou dépassent ce seuil.`, totalCoalitions: `Coalitions non vides possibles`, winningCoalitions: `Coalitions gagnantes`,
+};
+const softwareApplication: SoftwareApplication = { '@type': `SoftwareApplication`, name: `Calculateur de majorité des coalitions`, applicationCategory: `EducationalApplication`, operatingSystem: `Any`, description: `Énumérer les coalitions pondérées par les sièges, les groupes gagnants minimaux et les partis décisifs sous un seuil déclaré.`, url: `https://gamebob.dev/fr/calculateur-majorite-coalitions`, offers: { '@type': `Offer`, price: `0`, priceCurrency: `EUR` } };
+const faqPage: FAQPage = { '@type': `FAQPage`, mainEntity: [{ '@type': `Question`, name: `Quand une coalition est-elle minimale ?`, acceptedAnswer: { '@type': `Answer`, text: `Elle est minimale lorsque le départ de n'importe quel membre la fait passer sous le seuil de sièges déclaré. Une coalition excédentaire reste gagnante après le départ d'au moins un membre.` } }, { '@type': `Question`, name: `Que signifie décisif ?`, acceptedAnswer: { '@type': `Answer`, text: `Un parti est compté comme décisif chaque fois que son départ transforme une coalition gagnante en coalition perdante. Sa part est divisée par le total des défections critiques.` } }, { '@type': `Question`, name: `Le calculateur prédit-il un gouvernement réel ?`, acceptedAnswer: { '@type': `Answer`, text: `Non. Il évalue uniquement les poids de sièges et le seuil déclarés. L'idéologie, la négociation, le soutien minoritaire et les règles constitutionnelles sont exclus.` } }, { '@type': `Question`, name: `Pourquoi la limite est-elle de 20 partis ?`, acceptedAnswer: { '@type': `Answer`, text: `L'outil vérifie chaque sous-ensemble non vide. Vingt partis produisent déjà 1 048 575 combinaisons, une limite pratique dans un navigateur.` } }] };
+const howTo: HowTo = { '@type': `HowTo`, name: `Explorer une majorité pondérée`, step: [{ '@type': `HowToStep`, name: `Saisir les partis`, text: `Ajoutez chaque parti et son nombre de sièges. Des noms distincts rendent le résultat vérifiable.` }, { '@type': `HowToStep`, name: `Définir le seuil`, text: `Saisissez le nombre de sièges qu'une coalition doit atteindre.` }, { '@type': `HowToStep`, name: `Inspecter la constellation`, text: `Repérez les anneaux accentués et comparez les comptes décisifs aux sièges.` }, { '@type': `HowToStep`, name: `Lire le tableau`, text: `Comparez coalitions minimales, excédent et membres redondants.` }, { '@type': `HowToStep`, name: `Tester un autre scénario`, text: `Modifiez un nombre de sièges ou le seuil à la fois.` }] };
+export const content: CoalitionMajorityLocaleContent = { slug: `calculateur-majorite-coalitions`, title: `Calculateur de majorité des coalitions`, description: `Explorez chaque coalition fondée sur les sièges sous un seuil de majorité déclaré. Trouvez les groupes minimaux, l'excédent et les partis décisifs.`, ui, seo: [{ type: `title`, text: `Quelles combinaisons de sièges atteignent la majorité`, level: 2 }, { type: `paragraph`, html: `Une coalition est gagnante lorsque les sièges de ses membres atteignent ou dépassent le seuil que vous déclarez. Ce calculateur énumère chaque combinaison non vide et indique l'excédent exact. Vous pouvez ainsi vérifier pourquoi un groupe gagne.` }, { type: `title`, text: `Coalitions minimales et coalitions excédentaires`, level: 2 }, { type: `paragraph`, html: `Une coalition gagnante minimale perd sa majorité dès qu'un membre part. Une coalition excédentaire reste au-dessus du seuil après le départ d'un ou plusieurs membres. Cette distinction porte sur les sièges, pas sur la stabilité politique.` }, { type: `table`, headers: [`Résultat`, `Test appliqué`, `Ce que cela montre`], rows: [[`Coalition gagnante`, `Les sièges atteignent le seuil.`, `Quels groupes peuvent gagner en principe.`], [`Coalition gagnante minimale`, `Chaque membre est nécessaire au gain.`, `Quels groupes n'ont aucun excédent arithmétique.`], [`Coalition excédentaire`, `Au moins un membre peut partir et le groupe gagne encore.`, `Où une majorité possède des partenaires redondants.`]] }, { type: `title`, text: `Lire les partis décisifs comme une arithmétique`, level: 2 }, { type: `paragraph`, html: `Le compte décisif utilise un test de défection critique de type Banzhaf. Un parti compte lorsque son départ transforme une coalition gagnante en coalition perdante. La part est normalisée sur toutes les défections critiques du scénario.` }, { type: `list`, items: [`Commencez par le total des sièges et appliquez le seuil de votre règle.`, `Gardez le même seuil pour comparer deux répartitions.`, `Consultez les membres redondants avant d'interpréter la liste des partis décisifs.`, `Modifiez un seul parti à la fois pour comprendre la sensibilité.`, `Considérez les noms doublons et les partis sans siège comme des problèmes de données.`] }, { type: `title`, text: `Une recherche exacte encadrée`, level: 2 }, { type: `paragraph`, html: `Pour N partis, le calculateur évalue 2 puissance N moins 1 coalitions non vides. La limite de 20 garde la recherche exhaustive lisible et utilisable dans le navigateur. Le tableau présente un sous-ensemble lisible, tandis que les totaux couvrent toute la recherche.` }, { type: `tip`, title: `Les seuils sont des hypothèses, pas des lois`, html: `Le calculateur ne reconnaît ni règle constitutionnelle, ni investiture, ni majorité parlementaire valide. Saisissez le seuil vous-même et conservez cette règle avec le résultat.` }, { type: `title`, text: `Ce que le modèle ne peut pas déduire`, level: 2 }, { type: `paragraph`, html: `Les sièges décrivent la capacité à franchir un nombre, pas la volonté de coopérer. Le modèle n'évalue ni idéologie, ni distance politique, ni négociation, ni légitimité, ni stabilité, ni soutien extérieur.` }, { type: `tip`, title: `Utilisez le résultat comme piste d'audit`, html: `Lorsqu'un parti est décisif, trouvez une coalition gagnante où son départ franchit le seuil à la baisse. Pour une coalition excédentaire, examinez ses membres redondants.` }], faq: [{ question: `Quand une coalition est-elle minimale ?`, answer: `Lorsque le départ de chacun de ses membres la fait perdre. Si au moins un membre peut partir tout en conservant le seuil, la coalition est excédentaire.` }, { question: `Que signifie décisif ?`, answer: `Un parti est décisif dans chaque coalition gagnante qui devient perdante sans lui. Sa part est son compte critique divisé par le total critique.` }, { question: `Cela prédit-il un gouvernement réel ?`, answer: `Non. Seule l'arithmétique des sièges est évaluée. La compatibilité politique, la négociation et les règles constitutionnelles sont exclues.` }, { question: `Pourquoi vingt partis ?`, answer: `La recherche exacte vérifie 2 puissance N moins 1 combinaisons. Avec vingt partis, il y en a déjà 1 048 575.` }], bibliography, howTo: [{ name: `Saisir les partis`, text: `Ajoutez chaque parti avec ses sièges et un nom distinct.` }, { name: `Définir le seuil`, text: `Indiquez le nombre de sièges nécessaire pour gagner.` }, { name: `Examiner les partis décisifs`, text: `Utilisez les anneaux et les comptes pour repérer les partis nécessaires.` }, { name: `Lire le tableau`, text: `Comparez les groupes minimaux, l'excédent et les membres redondants.` }, { name: `Modifier une hypothèse`, text: `Ajustez un siège ou le seuil à la fois.` }], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/coalition-majority-calculator/i18n/id.ts

@@ -0,0 +1,45 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CoalitionMajorityLocaleContent } from '../entry';
+import type { CoalitionMajorityUI } from '../ui';
+
+const ui: CoalitionMajorityUI = {
+  addParty: 'Tambah partai', allCoalitions: 'Semua koalisi pemenang', calculate: 'Hitung koalisi', chamberSeats: 'Total kursi', coalitionSceneLabel: 'Konstelasi koalisi', criticalDefections: 'Pengunduran diri kritis', emptyState: 'Tambahkan setidaknya dua partai dan masukkan jumlah kursinya.', explanation: 'Model ini menganggap setiap partai dapat bergabung dengan kombinasi apa pun. Yang diukur adalah aritmetika kursi, bukan kecocokan politik.', edgeCasesText: 'Nama kosong atau ganda dibuat unik. Partai dengan nol kursi tidak pernah bisa menjadi penentu. Pencarian eksak berhenti di atas 20 partai.', edgeCasesTitle: 'Kasus batas dan peringatan', filterCoalitions: 'Tampilkan', maximumParties: 'Maksimal 20 partai karena enumerasi lengkap tumbuh sebagai 2 pangkat N.', majorityThreshold: 'Ambang mayoritas', methodTitle: 'Model yang digunakan', methodText: 'Setiap subset tidak kosong diperiksa. Koalisi menang jika mencapai ambang yang ditetapkan. Partai menjadi penentu jika pengunduran dirinya membuat koalisi pemenang kalah.', minimalCoalition: 'Koalisi pemenang minimal', noMatchingCoalitions: 'Tidak ada koalisi yang cocok dengan filter ini.', noPivots: 'Tidak ada partai yang menjadi penentu pada ambang ini.', none: 'Tidak ada', notDoText: 'Alat ini tidak menilai ideologi, kecocokan kebijakan, negosiasi, legitimasi, stabilitas, atau kemungkinan terbentuknya pemerintahan.', notDoTitle: 'Yang tidak dilakukan alat ini', partyName: 'Nama partai', partySeats: 'Kursi', partyTable: 'Detail koalisi', pivotal: 'penentu', pivotalParty: 'Partai penentu', redundantMembers: 'Anggota redundan', removeParty: 'Hapus partai', reset: 'Pulihkan contoh', resultTitle: 'Peta koalisi', seats: 'kursi', surplus: 'surplus', surplusCoalition: 'Koalisi surplus', threshold: 'Ambang', thresholdHint: 'Koalisi menang ketika jumlah kursinya mencapai atau melampaui ambang ini.', totalCoalitions: 'Koalisi tidak kosong yang mungkin', winningCoalitions: 'Koalisi pemenang',
+};
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Kalkulator Mayoritas Koalisi', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Enumerasi koalisi berbobot kursi, kelompok pemenang minimal, dan partai penentu di bawah ambang yang ditetapkan.', url: 'https://gamebob.dev/id/kalkulator-mayoritas-koalisi', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Kapan koalisi disebut minimal?', acceptedAnswer: { '@type': 'Answer', text: 'Koalisi minimal jika keluarnya anggota mana pun membuat jumlah kursinya turun di bawah ambang yang ditetapkan. Koalisi surplus tetap menang setelah setidaknya satu anggota keluar.' } },
+  { '@type': 'Question', name: 'Apa arti penentu?', acceptedAnswer: { '@type': 'Answer', text: 'Partai dihitung sebagai penentu setiap kali pengunduran dirinya mengubah koalisi pemenang menjadi koalisi kalah. Bagiannya dibagi dengan seluruh pengunduran diri kritis.' } },
+  { '@type': 'Question', name: 'Apakah kalkulator ini memprediksi pemerintahan nyata?', acceptedAnswer: { '@type': 'Answer', text: 'Tidak. Kalkulator hanya menilai bobot kursi dan ambang yang dimasukkan. Ideologi, negosiasi, dukungan minoritas, dan aturan konstitusional berada di luar model.' } },
+  { '@type': 'Question', name: 'Mengapa ada batas 20 partai?', acceptedAnswer: { '@type': 'Answer', text: 'Alat ini memeriksa setiap subset tidak kosong. Dua puluh partai sudah menghasilkan 1.048.575 kombinasi, batas yang praktis untuk browser.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Menjelajahi mayoritas berbobot', step: [
+  { '@type': 'HowToStep', name: 'Masukkan partai', text: 'Tambahkan setiap partai dan masukkan bobot kursinya. Gunakan nama yang berbeda agar hasil mudah diaudit.' },
+  { '@type': 'HowToStep', name: 'Atur ambang', text: 'Masukkan jumlah kursi yang harus dicapai koalisi untuk menang.' },
+  { '@type': 'HowToStep', name: 'Periksa konstelasi', text: 'Cari cincin aksen dan bandingkan hitungan penentu dengan jumlah kursi.' },
+  { '@type': 'HowToStep', name: 'Baca tabel koalisi', text: 'Bandingkan koalisi minimal, surplus kursi, dan anggota redundan.' },
+  { '@type': 'HowToStep', name: 'Uji skenario lain', text: 'Ubah satu jumlah kursi atau ambang setiap kali agar perubahan mudah dipahami.' },
+] };
+export const content: CoalitionMajorityLocaleContent = { slug: 'kalkulator-mayoritas-koalisi', title: 'Kalkulator Mayoritas Koalisi', description: 'Jelajahi setiap koalisi berbasis kursi di bawah ambang mayoritas yang ditetapkan, termasuk kelompok minimal, surplus, dan partai penentu.', ui, seo: [
+  { type: 'title', text: 'Kombinasi Kursi yang Dapat Mencapai Mayoritas', level: 2 },
+  { type: 'paragraph', html: 'Koalisi menang ketika kursi para anggotanya mencapai atau melampaui ambang yang Anda tetapkan. Kalkulator ini mencantumkan setiap kombinasi tidak kosong dan menunjukkan surplus tepat di atas ambang, sehingga alasan kemenangan dapat diperiksa.' },
+  { type: 'title', text: 'Koalisi Pemenang Minimal dan Surplus', level: 2 },
+  { type: 'paragraph', html: 'Koalisi pemenang minimal kehilangan mayoritas ketika satu anggota mana pun keluar. Koalisi surplus tetap berada di atas ambang setelah satu atau lebih anggota keluar. Ini adalah perbedaan aritmetika kursi, bukan ramalan stabilitas politik.' },
+  { type: 'table', headers: ['Hasil', 'Tes', 'Yang terlihat'], rows: [['Koalisi pemenang', 'Kursi anggota setidaknya sama dengan ambang.', 'Kelompok yang secara prinsip memiliki cukup kursi.'], ['Koalisi pemenang minimal', 'Setiap anggota penting untuk tetap menang.', 'Kelompok tanpa surplus aritmetika kursi.'], ['Koalisi surplus', 'Satu anggota dapat keluar dan kelompok tetap menang.', 'Mayoritas dengan mitra redundan.']] },
+  { type: 'title', text: 'Membaca Partai Penentu sebagai Aritmetika Kursi', level: 2 },
+  { type: 'paragraph', html: 'Hitungan penentu memakai uji pengunduran diri kritis bergaya Banzhaf. Partai dihitung ketika keluarnya mengubah koalisi pemenang menjadi kalah. Bagiannya dinormalisasi terhadap semua pengunduran diri kritis dalam skenario.' },
+  { type: 'list', items: ['Mulai dari total kursi dan gunakan ambang yang sesuai dengan aturan Anda.', 'Pertahankan ambang yang sama saat membandingkan dua pembagian kursi.', 'Periksa anggota redundan di tabel sebelum menafsirkan daftar partai penentu.', 'Ubah satu partai setiap kali untuk melihat sensitivitas.', 'Anggap nama ganda dan partai tanpa kursi sebagai masalah data.'] },
+  { type: 'title', text: 'Pencarian Eksak yang Terbatas', level: 2 },
+  { type: 'paragraph', html: 'Untuk N partai, kalkulator mengevaluasi 2 pangkat N dikurangi 1 koalisi tidak kosong. Batas 20 partai menjaga pencarian lengkap tetap transparan dan nyaman di browser. Tabel menampilkan bagian yang mudah dibaca, sedangkan ringkasan mencakup seluruh pencarian.' },
+  { type: 'tip', title: 'Ambang adalah asumsi, bukan hukum', html: 'Kalkulator tidak mengenali aturan negara, pelantikan, perjanjian kepercayaan, atau mayoritas parlemen yang sah. Masukkan ambang sendiri dan simpan aturannya bersama hasil.' },
+  { type: 'title', text: 'Yang Tidak Dapat Disimpulkan Model', level: 2 },
+  { type: 'paragraph', html: 'Bobot kursi menunjukkan kemampuan melewati angka, bukan kemungkinan bekerja sama. Model tidak menilai ideologi, jarak kebijakan, negosiasi, legitimasi, stabilitas, faksi internal, atau dukungan dari luar.' },
+  { type: 'tip', title: 'Gunakan hasil sebagai jejak audit', html: 'Jika sebuah partai ditandai sebagai penentu, temukan koalisi pemenang yang turun melewati ambang ketika partai itu keluar. Untuk koalisi surplus, periksa anggota redundannya.' },
+], faq: [
+  { question: 'Kapan koalisi disebut minimal?', answer: 'Ketika keluarnya anggota mana pun membuat koalisi kalah. Jika satu anggota dapat keluar dan ambang tetap tercapai, koalisi itu memiliki surplus.' },
+  { question: 'Apa arti penentu?', answer: 'Partai penentu ada di setiap koalisi pemenang yang menjadi kalah tanpa dirinya. Bagiannya adalah hitungan kritis dibagi total kritis.' },
+  { question: 'Apakah ini memprediksi pemerintahan nyata?', answer: 'Tidak. Ini hanya mengevaluasi aritmetika kursi. Kecocokan politik, negosiasi, dan aturan konstitusional berada di luar model.' },
+  { question: 'Mengapa batasnya 20 partai?', answer: 'Pencarian eksak memeriksa 2 pangkat N dikurangi 1 kombinasi. Dua puluh partai menghasilkan 1.048.575 kombinasi.' },
+], bibliography, howTo: [
+  { name: 'Masukkan partai', text: 'Tambahkan partai dengan kursi dan nama yang berbeda.' }, { name: 'Atur ambang', text: 'Masukkan jumlah kursi yang diperlukan untuk menang.' }, { name: 'Periksa partai penentu', text: 'Gunakan cincin dan hitungan untuk menemukan partai yang diperlukan.' }, { name: 'Baca tabel', text: 'Bandingkan kelompok minimal, surplus, dan anggota redundan.' }, { name: 'Ubah satu asumsi', text: 'Sesuaikan satu jumlah kursi atau ambang setiap kali.' },
+], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };