@jjlmoya/utils-civic 1.7.0 → 1.9.0

package/src/tool/parliamentary-voting-analyzer/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import Bibliography from '@jjlmoya/utils-shared/ui/Bibliography.astro';
+import { parliamentaryVotingAnalyzer } from './entry';
+
+interface Props {
+  locale?: string;
+}
+
+const { locale = 'en' } = Astro.props;
+const loader = parliamentaryVotingAnalyzer.i18n[locale as keyof typeof parliamentaryVotingAnalyzer.i18n] ?? parliamentaryVotingAnalyzer.i18n.en;
+const content = await loader!();
+---
+
+<Bibliography links={content.bibliography} />

package/src/tool/parliamentary-voting-analyzer/bibliography.ts

@@ -0,0 +1,6 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  { name: 'Cambridge University Press, CongressBR: An R Package for Analyzing Data from Brazil\'s Chamber of Deputies and Federal Senate', url: 'https://www.cambridge.org/core/journals/latin-american-research-review/article/congressbr-an-r-package-for-analyzing-data-from-brazils-chamber-of-deputies-and-federal-senate/697BB8D9ADD0DC4E42DD0D6EC58CB26D' },
+  { name: 'Assemblée nationale, Les votes à l\'Assemblée nationale', url: 'https://questions.assemblee-nationale.fr/synthese/fonctionnement-assemblee-nationale/travail-legislatif/les-votes-a-l-assemblee-nationale' },
+];

package/src/tool/parliamentary-voting-analyzer/component.astro

@@ -0,0 +1,63 @@
+---
+import type { ParliamentaryVotingUI } from './ui';
+
+interface Props {
+  ui: ParliamentaryVotingUI;
+  locale?: string;
+}
+
+const { ui } = Astro.props;
+---
+
+<section class="parliamentary-voting-analyzer" data-parliamentary-voting-analyzer>
+  <div class="pv-input-zone">
+    <div class="pv-input-copy">
+      <p class="pv-eyebrow">{ui.dataHeading}</p>
+      <p>{ui.dataHelp}</p>
+    </div>
+    <label class="pv-field-label" for="pv-roll-call">{ui.csvLabel}</label>
+    <p class="pv-csv-hint">{ui.csvHint}</p>
+    <textarea id="pv-roll-call" rows="8" spellcheck="false"></textarea>
+    <div class="pv-actions">
+      <button type="button" class="pv-primary-action" data-analyze>{ui.analyzeAction}</button>
+      <button type="button" class="pv-secondary-action" data-example>{ui.loadExample}</button>
+      <button type="button" class="pv-secondary-action" data-clear>{ui.clearAction}</button>
+    </div>
+    <p class="pv-feedback" data-feedback aria-live="polite"></p>
+  </div>
+  <div class="pv-mode-zone">
+    <fieldset>
+      <legend>{ui.compareLabel}</legend>
+      <label><input type="radio" name="pv-compare" value="groups" checked /> <span>{ui.groupsOption}</span></label>
+      <label><input type="radio" name="pv-compare" value="members" /> <span>{ui.membersOption}</span></label>
+    </fieldset>
+    <div class="pv-method-strip">
+      <span class="pv-method-line" aria-hidden="true"></span>
+      <span>{ui.cohesionHelp}</span>
+    </div>
+  </div>
+  <div data-result>
+    <div class="pv-empty">
+      <div class="pv-empty-mark" aria-hidden="true"></div>
+      <p>{ui.emptyResult}</p>
+    </div>
+  </div>
+  <div class="pv-note-zone">
+    <div><h3>{ui.methodHeading}</h3><p>{ui.methodText}</p></div>
+    <div><h3>{ui.limitsHeading}</h3><p>{ui.limitsText}</p></div>
+    <div><h3>{ui.edgeHeading}</h3><p>{ui.edgeText}</p></div>
+  </div>
+</section>
+
+<script is:inline type="application/json" data-pv-data set:html={JSON.stringify({ ui })}></script>
+<script>
+  import { initParliamentaryVotingAnalyzer } from './controller';
+  import type { ParliamentaryVotingUI } from './ui';
+
+  const payload = document.querySelector('script[data-pv-data]');
+  const root = document.querySelector('[data-parliamentary-voting-analyzer]');
+  if (payload instanceof HTMLScriptElement && root instanceof HTMLElement) {
+    const data = JSON.parse(payload.textContent ?? '{}') as { ui: ParliamentaryVotingUI };
+    initParliamentaryVotingAnalyzer(root, data.ui);
+  }
+</script>

package/src/tool/parliamentary-voting-analyzer/contract.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { parliamentaryVotingAnalyzer } from './entry';
+import { PARLIAMENTARY_VOTING_ANALYZER_TOOL } from './index';
+
+describe('parliamentary voting analyzer runtime contract', () => {
+  it('exposes the English content and the three page component loaders', async () => {
+    const content = await parliamentaryVotingAnalyzer.i18n.en?.();
+    expect(content?.slug).toBe('parliamentary-voting-analyzer');
+    expect(content?.ui).toBeDefined();
+    expect(content?.seo.length).toBeGreaterThan(0);
+    expect(content?.schemas.length).toBe(3);
+    expect(typeof PARLIAMENTARY_VOTING_ANALYZER_TOOL.Component).toBe('function');
+    expect(typeof PARLIAMENTARY_VOTING_ANALYZER_TOOL.SEOComponent).toBe('function');
+    expect(typeof PARLIAMENTARY_VOTING_ANALYZER_TOOL.BibliographyComponent).toBe('function');
+  });
+});

package/src/tool/parliamentary-voting-analyzer/controller.ts

@@ -0,0 +1,65 @@
+import { analyzeRollCall, parseRollCall } from './logic';
+import { buildCopyText, renderAnalysis } from './dom-views';
+import { clearDraft, loadDraft, saveDraft } from './storage';
+import type { ParliamentaryVotingUI } from './ui';
+
+const exampleCsv = 'member,group,vote,choice\nAmina Rahal,Harbor Group,Bill 1,yes\nLuis Chen,Harbor Group,Bill 1,yes\nMarta Silva,Harbor Group,Bill 1,no\nAmina Rahal,Harbor Group,Bill 2,abstain\nLuis Chen,Harbor Group,Bill 2,yes\nMarta Silva,Harbor Group,Bill 2,yes\nOwen Price,Civic List,Bill 1,no\nNora Iqbal,Civic List,Bill 1,no\nOwen Price,Civic List,Bill 2,absent\nNora Iqbal,Civic List,Bill 2,yes\nSofia Marin,Bridge Group,Bill 1,unknown\nSofia Marin,Bridge Group,Bill 2,yes';
+
+const query = <T extends Element>(root: ParentNode, selector: string): T | null => root.querySelector<T>(selector);
+
+const readMode = (root: ParentNode): 'members' | 'groups' => query<HTMLInputElement>(root, 'input[name="pv-compare"]:checked')?.value === 'members' ? 'members' : 'groups';
+
+const update = (root: HTMLElement, ui: ParliamentaryVotingUI): void => {
+  const textarea = query<HTMLTextAreaElement>(root, 'textarea');
+  const result = query<HTMLElement>(root, '[data-result]');
+  if (!textarea || !result) return;
+  const analysis = analyzeRollCall(parseRollCall(textarea.value));
+  const emptyMessage = textarea.value.trim() ? ui.invalidCsvMessage : ui.emptyResult;
+  result.innerHTML = analysis.records.length ? renderAnalysis(analysis, readMode(root), ui) : `<div class="pv-empty"><div class="pv-empty-mark" aria-hidden="true"></div><p>${emptyMessage}</p></div>`;
+  root.dataset.copyText = buildCopyText(analysis, readMode(root));
+};
+
+const copySummary = async (root: HTMLElement, ui: ParliamentaryVotingUI): Promise<void> => {
+  const text = root.dataset.copyText ?? '';
+  const feedback = query<HTMLElement>(root, '[data-feedback]');
+  if (!text || !feedback) return;
+  try {
+    await navigator.clipboard.writeText(text);
+    feedback.textContent = ui.copiedMessage;
+  } catch {
+    feedback.textContent = ui.copyFailure;
+  }
+};
+
+const handleExample = (root: HTMLElement, textarea: HTMLTextAreaElement, ui: ParliamentaryVotingUI): void => {
+  textarea.value = exampleCsv;
+  saveDraft(exampleCsv);
+  const feedback = query<HTMLElement>(root, '[data-feedback]');
+  if (feedback) feedback.textContent = ui.importedMessage;
+  update(root, ui);
+};
+
+const handleClick = (root: HTMLElement, textarea: HTMLTextAreaElement, ui: ParliamentaryVotingUI, event: Event): void => {
+  const target = event.target as HTMLElement;
+  if (target.closest('[data-example]')) handleExample(root, textarea, ui);
+  if (target.closest('[data-clear]')) {
+    textarea.value = '';
+    clearDraft();
+    update(root, ui);
+  }
+  if (target.closest('[data-analyze]')) update(root, ui);
+  if (target.closest('[data-copy-summary]')) void copySummary(root, ui);
+};
+
+export const initParliamentaryVotingAnalyzer = (root: HTMLElement, ui: ParliamentaryVotingUI): void => {
+  const textarea = query<HTMLTextAreaElement>(root, 'textarea');
+  if (!textarea) return;
+  const draft = loadDraft();
+  if (draft) textarea.value = draft;
+  update(root, ui);
+  root.addEventListener('input', (event) => {
+    if (event.target === textarea) saveDraft(textarea.value);
+  });
+  root.addEventListener('change', () => update(root, ui));
+  root.addEventListener('click', (event) => handleClick(root, textarea, ui, event));
+};

package/src/tool/parliamentary-voting-analyzer/dom-views.ts

@@ -0,0 +1,63 @@
+import type { AnalysisResult, GroupVoteResult, PairwiseResult } from './logic';
+import type { ParliamentaryVotingUI } from './ui';
+
+const escapeHtml = (value: string): string => value.replace(/[&<>'"]/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', "'": '&#39;', '"': '&quot;' }[character] ?? character));
+
+const formatRate = (value: number | null): string => value === null ? 'Not available' : `${Math.round(value * 100)}%`;
+
+const choiceClass = (item: GroupVoteResult): string => {
+  if (item.yes === item.no && item.comparable > 0) return 'is-tie';
+  if (item.yes > item.no) return 'is-yes';
+  if (item.no > item.yes) return 'is-no';
+  if (item.abstain > 0) return 'is-abstain';
+  return 'is-quiet';
+};
+
+const renderRibbon = (result: AnalysisResult, ui: ParliamentaryVotingUI): string => {
+  const votes = [...new Set(result.groupVotes.map((item) => item.vote))];
+  const rows = result.summaries.map((summary) => {
+    const cells = votes.map((vote) => {
+      const item = result.groupVotes.find((candidate) => candidate.group === summary.group && candidate.vote === vote);
+      return item ? `<span class="pv-ribbon-cell ${choiceClass(item)}" title="${escapeHtml(vote)}: ${item.yes} yes, ${item.no} no" aria-label="${escapeHtml(vote)} ${item.yes} yes ${item.no} no"></span>` : '<span class="pv-ribbon-cell is-missing" aria-label="No record"></span>';
+    }).join('');
+    return `<div class="pv-ribbon-row"><span class="pv-ribbon-name">${escapeHtml(summary.group)}</span><span class="pv-ribbon-track">${cells}</span><span class="pv-ribbon-score">${formatRate(summary.meanRice)}</span></div>`;
+  }).join('');
+  const labels = votes.map((vote) => `<span>${escapeHtml(vote)}</span>`).join('');
+  return `<div class="pv-ribbon-head"><span>${escapeHtml(ui.groupLabel)}</span><span><small>${escapeHtml(ui.voteLabel)}</small><span class="pv-ribbon-votes">${labels}</span></span><span>${escapeHtml(ui.riceLabel)}</span></div>${rows}`;
+};
+
+const renderSummary = (result: AnalysisResult, ui: ParliamentaryVotingUI): string => result.summaries.map((summary) => `<div class="pv-summary-line"><strong>${escapeHtml(summary.group)}</strong><span>${formatRate(summary.meanRice)} ${escapeHtml(ui.riceLabel)}</span><span>${summary.comparableVotes}/${summary.votes} ${escapeHtml(ui.comparableLabel)}</span><span>${escapeHtml(ui.participationLabel)}: ${summary.yes} yes · ${summary.no} no · ${summary.abstain} ${escapeHtml(ui.abstentionsLabel)} · ${summary.absent} ${escapeHtml(ui.absencesLabel)}</span></div>`).join('');
+
+const renderPair = (item: PairwiseResult): string => `<tr><th scope="row">${escapeHtml(item.left)}</th><td>${escapeHtml(item.right)}</td><td>${formatRate(item.agreementRate)}</td><td>${item.agreements}/${item.comparableVotes}</td></tr>`;
+
+const hasLowSample = (result: AnalysisResult): boolean => result.memberAgreement.some((item) => item.comparableVotes < 2) || result.groupAgreement.some((item) => item.comparableVotes < 2);
+
+const hasGroupTie = (result: AnalysisResult): boolean => result.groupAgreement.some((item) => item.comparableVotes === 0);
+
+const hasVoteTie = (result: AnalysisResult): boolean => result.groupVotes.some((item) => item.yes === item.no && item.comparable > 0);
+
+const hasAnyTie = (result: AnalysisResult): boolean => hasGroupTie(result) || hasVoteTie(result);
+
+const renderWarnings = (result: AnalysisResult, ui: ParliamentaryVotingUI): string => {
+  const warnings: string[] = [];
+  if (!result.records.length) warnings.push(ui.noDataWarning);
+  if (result.skippedRows) warnings.push(`${ui.malformedRowWarning} ${result.skippedRows}`);
+  if (result.duplicateRecords) warnings.push(`${ui.duplicateWarning} ${result.duplicateRecords}`);
+  if (result.unknownChoices) warnings.push(`${ui.unknownChoiceWarning} ${result.unknownChoices} ${ui.unknownLabel}`);
+  if (hasAnyTie(result)) warnings.push(ui.tieWarning);
+  if (hasLowSample(result)) warnings.push(ui.lowSampleWarning);
+  return warnings.length ? `<div class="pv-warnings" role="status"><h3>${escapeHtml(ui.warningsHeading)}</h3><ul>${warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join('')}</ul></div>` : '';
+};
+
+export const renderAnalysis = (result: AnalysisResult, mode: 'members' | 'groups', ui: ParliamentaryVotingUI): string => {
+  const pairs = mode === 'members' ? result.memberAgreement : result.groupAgreement;
+  const pairRows = pairs.length ? pairs.map(renderPair).join('') : `<tr><td colspan="4">${escapeHtml(ui.noComparableData)}</td></tr>`;
+  return `<section class="pv-result" aria-live="polite"><div class="pv-result-intro"><div><p class="pv-eyebrow">${escapeHtml(ui.resultHeading)}</p><p class="pv-countline"><strong>${result.records.length}</strong> ${escapeHtml(ui.rowsLabel)} <strong>${result.groupCount}</strong> ${escapeHtml(ui.groupsLabel)} <strong>${result.voteCount}</strong> ${escapeHtml(ui.votesLabel)}</p></div><button type="button" class="pv-quiet-action" data-copy-summary>${escapeHtml(ui.copyAction)}</button></div><div class="pv-ribbon" aria-label="${escapeHtml(ui.cohesionHeading)}">${renderRibbon(result, ui)}</div><p class="pv-legend"><span class="pv-dot is-yes"></span> yes <span class="pv-dot is-no"></span> no <span class="pv-dot is-abstain"></span> abstention <span class="pv-dot is-quiet"></span> absence or unknown</p><div class="pv-result-detail"><div><h3>${escapeHtml(ui.cohesionHeading)}</h3><p>${escapeHtml(ui.cohesionHelp)}</p><div class="pv-summary-list">${renderSummary(result, ui)}</div></div><div><h3>${escapeHtml(ui.agreementHeading)}</h3><p>${escapeHtml(ui.agreementHelp)}</p><div class="pv-table-wrap"><table><thead><tr><th>${escapeHtml(ui.groupLabel)}</th><th>${escapeHtml(ui.compareLabel)}</th><th>${escapeHtml(ui.agreementHeading)}</th><th>${escapeHtml(ui.comparableLabel)}</th></tr></thead><tbody>${pairRows}</tbody></table></div></div></div>${renderWarnings(result, ui)}</section>`;
+};
+
+export const buildCopyText = (result: AnalysisResult, mode: 'members' | 'groups'): string => {
+  const pairs = mode === 'members' ? result.memberAgreement : result.groupAgreement;
+  const summary = result.summaries.map((item) => `${item.group}: Rice ${formatRate(item.meanRice)} across ${item.comparableVotes}/${item.votes} comparable votes`).join('\n');
+  const agreement = pairs.map((item) => `${item.left} and ${item.right}: ${formatRate(item.agreementRate)} across ${item.comparableVotes} comparable votes`).join('\n');
+  return `Parliamentary voting analysis\n${summary}\n\nPairwise agreement\n${agreement}`;
+};

package/src/tool/parliamentary-voting-analyzer/entry.ts

@@ -0,0 +1,27 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { ParliamentaryVotingUI } from './ui';
+
+export type ParliamentaryVotingLocaleContent = ToolLocaleContent<ParliamentaryVotingUI>;
+
+export const parliamentaryVotingAnalyzer: CivicToolEntry<ParliamentaryVotingUI> = {
+  id: 'parliamentary-voting-analyzer',
+  phase: 'localized',
+  icons: { bg: 'mdi:vote-outline', fg: 'mdi:chart-timeline-variant' },
+  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/parliamentary-voting-analyzer/evaluator.ts

@@ -0,0 +1,12 @@
+import type { AnalysisResult } from './logic';
+
+export interface AnalysisStatus {
+  tone: 'empty' | 'ready' | 'warning';
+  message: string;
+}
+
+export const evaluateAnalysis = (result: AnalysisResult, emptyMessage: string): AnalysisStatus => {
+  if (!result.records.length) return { tone: 'empty', message: emptyMessage };
+  if (!result.groupVotes.some((item) => item.rice !== null)) return { tone: 'warning', message: 'The data has no comparable yes or no choices for a Rice Index.' };
+  return { tone: 'ready', message: 'The record has enough binary choices to inspect cohesion.' };
+};

package/src/tool/parliamentary-voting-analyzer/i18n/de.ts

@@ -0,0 +1,45 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { ParliamentaryVotingLocaleContent } from '../entry';
+import type { ParliamentaryVotingUI } from '../ui';
+import type { ToolLocaleContent } from '../../../types';
+
+const ui: ParliamentaryVotingUI = {
+  dataHeading: 'Eine namentliche Abstimmung sichtbar machen', dataHelp: 'Füge eine Zeile pro Mitglied und Abstimmung ein. Verwende die vier Spalten Mitglied, Gruppe, Abstimmung und Entscheidung.', csvLabel: 'CSV der namentlichen Abstimmung', csvHint: 'Pflichtspalten: Mitglied, Gruppe, Abstimmung, Entscheidung. Erlaubt: Ja, Nein, Enthaltung, abwesend, unbekannt.', loadExample: 'Beispiel laden', analyzeAction: 'Abstimmungen analysieren', clearAction: 'Daten löschen', compareLabel: 'Übereinstimmungsansicht', groupsOption: 'Gruppen', membersOption: 'Mitglieder', resultHeading: 'Das Abstimmungsprotokoll auf einen Blick', emptyResult: 'Füge eine Abstimmung ein oder lade das Beispiel, um das Abstimmungsband zu sehen.', rowsLabel: 'Einträge', groupsLabel: 'Gruppen', votesLabel: 'Abstimmungen', warningsHeading: 'Prüfungen vor der Interpretation', methodHeading: 'Angewandte Methode', methodText: 'Der Rice-Index für jede Gruppe und Abstimmung ist die absolute Differenz zwischen Ja und Nein geteilt durch Ja plus Nein. Enthaltungen, Abwesenheiten und unbekannte Werte werden aus diesem binären Nenner ausgeschlossen. Gruppenmittel sind ungewichtete Mittelwerte der Abstimmungen mit mindestens einem Ja oder Nein. Die Übereinstimmung vergleicht binäre Entscheidungen derselben Abstimmung und zeigt immer die Zahl vergleichbarer Abstimmungen.', limitsHeading: 'Was dieses Werkzeug nicht leistet', limitsText: 'Es leitet keine Ideologie, Absicht, Disziplin, Absprache, Fehlverhalten, politischen Positionen oder Kausalität ab. Es entscheidet auch nicht, ob eine Abstimmung gültig war oder ein Mitglied rechtlich zur Anwesenheit verpflichtet war. Ähnliche Abstimmungen können viele Erklärungen haben.', edgeHeading: 'Grenzfälle und Datenhinweise', edgeText: 'Einstimmige Abstimmungen erhalten den Wert 1, sind aber kein Beweis für Disziplin. Unentschieden ergeben null Zusammenhalt und werden getrennt von Enthaltungen markiert. Fehlende Stimmen verkleinern die Vergleichsmenge. Halte wechselnde Gruppenzugehörigkeiten, doppelte Kennungen und unbekannte Entscheidungen in den Quelldaten sichtbar.', cohesionHeading: 'Zusammenhaltsband', cohesionHelp: 'Jede Zeile ist eine Gruppe. Eine helle Markierung bedeutet Ja, eine dunkle Nein, eine gestrichelte Gleichstand, eine hohle Enthaltung und eine blasse Markierung Abwesenheit oder unbekannte Daten.', agreementHeading: 'Paarweise Übereinstimmung', agreementHelp: 'Die Übereinstimmung nutzt nur vergleichbare Ja- und Nein-Entscheidungen, die beide Entitäten teilen. In der Gruppenansicht steuert jede Gruppe ihre nicht unentschiedene Mehrheitsentscheidung bei. Enthaltungen und Nichtteilnahmen bleiben aus Zähler und Nenner heraus.', groupLabel: 'Gruppe', voteLabel: 'Abstimmung', riceLabel: 'Rice-Index', comparableLabel: 'Vergleichbare Abstimmungen', participationLabel: 'Erfasste Entscheidungen', abstentionsLabel: 'Enthaltungen', absencesLabel: 'Abwesenheiten', unknownLabel: 'unbekannt', noComparableData: 'Keine vergleichbaren Ja- oder Nein-Entscheidungen', noDataWarning: 'Keine nutzbaren Einträge gefunden. Ergänze Werte für Mitglied, Gruppe, Abstimmung und Entscheidung.', malformedRowWarning: 'Einige Zeilen wurden wegen eines leeren Pflichtfelds übersprungen.', duplicateWarning: 'Doppelte Kombinationen aus Mitglied und Abstimmung wurden nur einmal übernommen.', unknownChoiceWarning: 'Einige Entscheidungen blieben unbekannt, weil sie nicht als Ja, Nein, Enthaltung oder Abwesenheit erkannt wurden.', lowSampleWarning: 'Einige Paarvergleiche haben weniger als zwei vergleichbare Abstimmungen und sollten nicht als stabiles Muster gelten.', tieWarning: 'Ein Gleichstand einer Gruppe oder Entität wurde für diese Abstimmung aus dem Gruppenvergleich ausgeschlossen.', importedMessage: 'Beispiel geladen. Du kannst die Zeilen vor der Analyse bearbeiten.', invalidCsvMessage: 'Die Daten konnten nicht als zeilenbasiertes CSV gelesen werden.', copyAction: 'Zusammenfassung kopieren', copiedMessage: 'Zusammenfassung in die Zwischenablage kopiert.', copyFailure: 'Kopieren fehlgeschlagen. Wähle den Zusammenfassungstext manuell aus.',
+};
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Analysator parlamentarischer Abstimmungen', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Analysiert Zusammenhalt und paarweise Übereinstimmung parlamentarischer namentlicher Abstimmungen anhand einer transparenten Stimmenmatrix.', url: 'https://gamebob.dev/de/parlamentarische-abstimmungsanalyse', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Was misst der Rice-Index?', acceptedAnswer: { '@type': 'Answer', text: 'Für eine Gruppe und eine Abstimmung ist er die absolute Differenz zwischen Ja- und Nein-Stimmen geteilt durch ihre Summe. Er reicht von null bei einer Teilung bis eins bei einer einstimmigen binären Abstimmung.' } },
+  { '@type': 'Question', name: 'Werden Enthaltungen und Abwesenheiten berücksichtigt?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Der binäre Rice-Nenner verwendet nur Ja und Nein. Enthaltungen, Abwesenheiten und unbekannte Werte bleiben als Beteiligungssignale sichtbar, fließen aber nicht in den binären Wert ein.' } },
+  { '@type': 'Question', name: 'Beweist Übereinstimmung eine gemeinsame Ideologie?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Übereinstimmung beschreibt nur die aufgezeichneten binären Entscheidungen in den vergleichbaren Abstimmungen. Sie bestimmt weder Ideologie noch Absicht, Absprache oder Kausalität.' } },
+  { '@type': 'Question', name: 'Warum werden vergleichbare Abstimmungen gezählt?', acceptedAnswer: { '@type': 'Answer', text: 'Ein Prozentsatz ohne Nenner kann fehlende Einträge verbergen. Der vergleichbare Wert zeigt, wie viele gemeinsame Abstimmungen tatsächlich in die Übereinstimmungsrate eingingen.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Parlamentarische namentliche Abstimmungen analysieren', step: [
+  { '@type': 'HowToStep', name: 'Eine Zeile pro Entscheidung vorbereiten', text: 'Erstelle CSV-Zeilen mit den Spalten Mitglied, Gruppe, Abstimmung und Entscheidung. Verwende Ja, Nein, Enthaltung, abwesend oder unbekannt.' },
+  { '@type': 'HowToStep', name: 'Die Matrix laden', text: 'Füge das CSV ein oder lade das Beispiel und prüfe, ob Gruppen- und Abstimmungszahlen zur Quelle passen.' },
+  { '@type': 'HowToStep', name: 'Gruppenzusammenhalt lesen', text: 'Nutze Band und Rice-Zusammenfassung, um den binären Zusammenhalt jeder Gruppe und Abstimmung zu prüfen.' },
+  { '@type': 'HowToStep', name: 'Entscheidungen vergleichen', text: 'Wechsle zwischen Gruppen- und Mitgliedervergleich und lies jede Rate zusammen mit der Zahl vergleichbarer Abstimmungen.' },
+  { '@type': 'HowToStep', name: 'Hinweise prüfen', text: 'Untersuche übersprungene Zeilen, Duplikate, unbekannte Entscheidungen, Gleichstände und kleine Stichproben.' },
+] };
+const faqItems = (faqPage.mainEntity ?? []) as unknown as Array<{ name?: string; acceptedAnswer?: { text?: string } }>;
+const howToSteps = (howTo.step ?? []) as unknown as Array<{ name?: string; text?: string }>;
+const seo: ToolLocaleContent<ParliamentaryVotingUI>['seo'] = [
+  { type: 'title', text: 'Zusammenhalt in einer parlamentarischen namentlichen Abstimmung prüfen', level: 2 },
+  { type: 'paragraph', html: 'Eine namentliche Abstimmung zeigt, wer abgestimmt hat, aber eine lange Liste von Ja und Nein macht nicht sofort sichtbar, ob eine Gruppe geschlossen handelte. Dieser Analysator verwandelt eine zeilenbasierte Matrix in ein visuelles Abstimmungsband, Gruppenzusammenfassungen und paarweise Übereinstimmungen. Unterschiede im Ausgangsdatensatz bleiben erhalten, damit ein glatter Prozentsatz fehlende oder nicht binäre Entscheidungen nicht verdeckt.' },
+  { type: 'paragraph', html: 'Die vorgesehene Eingabe ist eine Tabelle mit einer Zeile für jedes Mitglied und jede Abstimmung. Jede Zeile enthält Mitglied, parlamentarische Gruppe, Abstimmungskennung und aufgezeichnete Entscheidung. Übliche Begriffe wie dafür, dagegen, Enthaltung und nicht abgestimmt werden erkannt; unbekannte Werte bleiben unbekannt, statt stillschweigend umcodiert zu werden.' },
+  { type: 'title', text: 'So wird der Rice-Index berechnet', level: 2 },
+  { type: 'paragraph', html: 'Für eine Gruppe in einer Abstimmung lautet der Rice-Index |Ja minus Nein| geteilt durch Ja plus Nein. Eine einstimmige binäre Abstimmung ergibt 1, eine gleichmäßige Teilung 0, und eine Gruppe ohne Ja oder Nein erhält keinen Rice-Wert. Die Gruppenzusammenfassung ist der ungewichtete Mittelwert verfügbarer Abstimmungswerte; fehlende binäre Angaben werden daher nicht als erfundene Nullen behandelt.' },
+  { type: 'table', headers: ['Signal', 'Berechnung', 'Bedeutung'], rows: [['Rice-Index', '|Ja minus Nein| / (Ja plus Nein)', 'Binärer Zusammenhalt von Gruppe und Abstimmung'], ['Mittlerer Rice', 'Mittelwert verfügbarer Abstimmungswerte', 'Typischer Zusammenhalt vergleichbarer Abstimmungen'], ['Übereinstimmung', 'Gleiche binäre Entscheidungen / vergleichbare gemeinsame Abstimmungen', 'Beobachtete Übereinstimmung zweier Entitäten']] },
+  { type: 'title', text: 'Eine überprüfbare Matrix vorbereiten', level: 2 },
+  { type: 'paragraph', html: 'Verwende für jede namentliche Abstimmung eine stabile Kennung und behalte die ursprünglichen Entscheidungskategorien bis nach dem Import. Wandle Abwesenheit nicht in Nein und Enthaltung nicht in eine leere Zelle um. Solche Entscheidungen verändern Beteiligungszahlen und die Menge vergleichbarer Beobachtungen.' },
+  { type: 'list', items: ['Bestätige, dass jede Zeile zum untersuchten Parlament, Zeitraum und Gremium gehört.', 'Schreibe Mitglieder- und Gruppennamen über alle Abstimmungen gleich, einschließlich Akzenten und Satzzeichen.', 'Vergib für getrennte namentliche Abstimmungen zu wiederholten Anträgen verschiedene Kennungen.', 'Prüfe doppelte Mitglied-Abstimmung-Paare anhand des Originals, bevor du die erste Zeile akzeptierst.', 'Bewahre Quelldatei und exakt importierten Text neben jeder veröffentlichten Interpretation auf.'] },
+  { type: 'tip', title: 'Ein Prozentsatz braucht seinen Nenner', html: 'Eine paarweise Übereinstimmung von 100 % bei zwei gemeinsamen Abstimmungen ist eine andere Evidenz als 100 % bei achtzig. Lies die vergleichbare Zahl neben jeder Rate und behandle kleine Stichproben als Anlass für mehr Daten, nicht als stabiles Muster.' },
+  { type: 'title', text: 'Das Band ohne Überinterpretation lesen', level: 2 },
+  { type: 'paragraph', html: 'Das Band ist eine Lesehilfe, kein politisches Urteil. Blaue Markierungen zeigen eine Gruppenmehrheit von Ja, rostfarbene eine Nein-Mehrheit, Umrisse eine Enthaltung und ruhige Markierungen Abwesenheit oder unbekannte Daten. Der Wert neben der Zeile fasst nur binäre Entscheidungen zusammen; Beteiligungszahlen zeigen, was aus dem Nenner ausgeschlossen wurde.' },
+  { type: 'paragraph', html: 'Hoher Zusammenhalt kann aus gemeinsamen Präferenzen, Parteidisziplin, Koalitionsverhandlungen, einem eng gefassten Antrag oder einer kleinen Gruppe entstehen. Hohe Übereinstimmung zweier Gruppen kann eine Tagesordnung mit wenig Streit widerspiegeln. Ein niedriger Wert kann echte Spaltung oder wechselnde Mitgliedsdaten bedeuten. Der Analysator beschreibt die Matrix und entscheidet nicht zwischen diesen Erklärungen.' },
+  { type: 'title', text: 'Methodische Grenzen und Datenhinweise', level: 2 },
+  { type: 'paragraph', html: 'Das Werkzeug verwendet die konventionelle binäre Rice-Berechnung und eine transparente Regel für paarweise Übereinstimmung. Es leitet weder Ideologie, Absicht, Fehlverhalten noch rechtliche Pflichten ab. Prüfe offizielle Definitionen der namentlichen Abstimmung, bevor du Enthaltung, Abwesenheit oder unbekannte Werte zwischen Parlamenten vergleichst.' },
+  { type: 'tip', title: 'Hinweise gehören zum Ergebnis', html: 'Übersprungene Zeilen, doppelte Kennungen, unbekannte Entscheidungen, Gleichstände und kleine vergleichbare Stichproben sind keine kosmetischen Meldungen. Kläre sie oder dokumentiere sie, bevor du Zeiträume, Gruppen oder Mitglieder vergleichst.' },
+];
+
+export const content: ParliamentaryVotingLocaleContent = { slug: 'parlamentarische-abstimmungsanalyse', title: 'Analysator parlamentarischer Abstimmungen', description: 'Miss Gruppenzusammenhalt und paarweise Übereinstimmung aus einer Matrix namentlicher Abstimmungen und halte Enthaltungen, Abwesenheiten, Nenner und Warnungen sichtbar.', ui, seo, faq: faqItems.map((item) => ({ question: String(item.name), answer: String(item.acceptedAnswer?.text) })), bibliography, howTo: howToSteps.map((step) => ({ name: String(step.name), text: String(step.text) })), schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[] };

package/src/tool/parliamentary-voting-analyzer/i18n/en.ts

@@ -0,0 +1,79 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { ParliamentaryVotingLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Parliamentary Voting Analyzer',
+  applicationCategory: 'EducationalApplication',
+  operatingSystem: 'Any',
+  description: 'Analyze parliamentary roll call cohesion and pairwise agreement from a transparent vote matrix.',
+  url: 'https://gamebob.dev/en/parliamentary-voting-analyzer',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'What does the Rice Index measure?', acceptedAnswer: { '@type': 'Answer', text: 'For one group and one vote, it is the absolute difference between yes and no votes divided by their sum. It ranges from zero for an even split to one for a unanimous binary vote.' } },
+    { '@type': 'Question', name: 'Are abstentions and absences included?', acceptedAnswer: { '@type': 'Answer', text: 'No. The binary Rice denominator uses only yes and no choices. Abstentions, absences, and unknown values remain visible as participation signals and are excluded from the binary score.' } },
+    { '@type': 'Question', name: 'Can agreement prove that two groups share an ideology?', acceptedAnswer: { '@type': 'Answer', text: 'No. Agreement only describes the recorded binary choices on the votes that both entities can be compared on. It does not identify ideology, intent, collusion, or causation.' } },
+    { '@type': 'Question', name: 'Why does the analyzer show comparable vote counts?', acceptedAnswer: { '@type': 'Answer', text: 'A percentage without its denominator can hide missing records. The comparable count shows how many shared votes actually contributed to each agreement rate.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Analyze parliamentary roll call votes',
+  step: [
+    { '@type': 'HowToStep', name: 'Prepare one row per choice', text: 'Create CSV rows with member, group, vote, and choice columns. Use yes, no, abstain, absent, or unknown for the choice.' },
+    { '@type': 'HowToStep', name: 'Load the matrix', text: 'Paste the CSV into the analyzer or load the example, then check that the group and vote counts match your source.' },
+    { '@type': 'HowToStep', name: 'Read group cohesion', text: 'Use the ribbon and Rice Index summary to inspect binary cohesion for each group and each vote.' },
+    { '@type': 'HowToStep', name: 'Compare choices', text: 'Switch between group and member agreement, and read every rate together with its comparable vote count.' },
+    { '@type': 'HowToStep', name: 'Review warnings', text: 'Investigate skipped rows, duplicates, unknown choices, ties, and low samples before drawing a conclusion.' },
+  ],
+};
+
+export const content: ToolLocaleContent<ParliamentaryVotingLocaleContent['ui']> = {
+  slug: 'parliamentary-voting-analyzer',
+  title: 'Parliamentary Voting Analyzer',
+  description: 'Measure group cohesion and pairwise voting agreement from a roll call matrix while keeping abstentions, absences, denominators, and warnings visible.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Inspect Cohesion in a Parliamentary Roll Call', level: 2 },
+    { type: 'paragraph', html: 'A roll call records who voted, but a long list of yes and no choices does not immediately show whether a group moved together. This analyzer turns a row based matrix into a visual voting ribbon, group summaries, and pairwise agreement results. It keeps the source distinctions visible so that a neat percentage does not erase missing or nonbinary choices.' },
+    { type: 'paragraph', html: 'The intended input is a table with one row for each member and vote. Each row names the member, parliamentary group, vote identifier, and recorded choice. The parser accepts common labels such as aye, nay, abstention, and no vote, but an unrecognized value is retained as unknown rather than silently recoded.' },
+    { type: 'title', text: 'How the Rice Index Is Calculated', level: 2 },
+    { type: 'paragraph', html: 'For one group on one vote, the Rice Index is |yes minus no| divided by yes plus no. A unanimous binary vote is 1, an even split is 0, and a group with no yes or no choice has no Rice value. The group summary is the unweighted mean of the available vote level scores, so a group with missing binary choices does not receive an invented zero.' },
+    { type: 'table', headers: ['Signal', 'Calculation', 'Interpretation'], rows: [['Rice Index', '|yes minus no| / (yes plus no)', 'Binary cohesion for one group and vote'], ['Mean Rice', 'Mean of available vote scores', 'Typical cohesion across comparable votes'], ['Agreement', 'Matching binary choices / comparable shared votes', 'Observed coincidence between two entities']] },
+    { type: 'title', text: 'Prepare a Matrix That Can Be Checked', level: 2 },
+    { type: 'paragraph', html: 'Use one stable vote identifier for every roll call and keep the original choice categories until after import. Do not turn absence into no, and do not turn abstention into a missing blank cell. Those decisions alter both participation counts and the set of observations that can be compared.' },
+    { type: 'list', items: ['Confirm that every row belongs to the same chamber and period you intend to study.', 'Keep member and group names consistent across votes, including accents and punctuation.', 'Give repeated motions distinct identifiers when they are separate roll calls.', 'Check duplicate member and vote pairs against the original record before accepting the first row.', 'Save the source file and the exact imported text beside any published interpretation.'] },
+    { type: 'tip', title: 'A percentage needs its denominator', html: 'A pairwise agreement of 100% over two shared votes is a different piece of evidence from 100% over eighty. Read the comparable count beside every rate, and treat a low sample as a prompt for more data rather than as a stable pattern.' },
+    { type: 'title', text: 'Interpret the Ribbon Without Overclaiming', level: 2 },
+    { type: 'paragraph', html: 'The ribbon is a reading aid, not a political verdict. Blue marks represent the group majority of yes choices, rust marks represent a majority of no choices, outlined marks show abstention, and quiet marks show absence or unknown data. The score beside a row summarizes binary choices only, while the participation counts show what was left out of that denominator.' },
+    { type: 'paragraph', html: 'High cohesion can arise from shared preferences, party discipline, coalition bargaining, a narrowly framed motion, or a small group. High agreement between two groups can reflect an agenda with little disagreement. A low score can reflect a genuinely divided vote or a changing membership record. The analyzer describes the matrix and cannot choose among those explanations.' },
+    { type: 'title', text: 'Method Limits and Data Warnings', level: 2 },
+    { type: 'paragraph', html: 'The tool follows the conventional binary Rice calculation and a transparent pairwise agreement rule. It does not infer ideology, intent, misconduct, or legal obligations. Check the official roll call definitions before treating an abstention, absence, or unknown value as comparable across parliaments.' },
+    { type: 'tip', title: 'Use warnings as part of the result', html: 'Skipped rows, duplicate identifiers, unknown choices, tied group majorities, and low comparable samples are not cosmetic notices. Resolve them or document them before comparing periods, groups, or members.' },
+  ],
+  faq: [
+    { question: 'What does the Rice Index measure?', answer: 'For one group and one vote, it is the absolute difference between yes and no votes divided by their sum. It ranges from zero for an even split to one for a unanimous binary vote.' },
+    { question: 'Are abstentions and absences included?', answer: 'No. The binary Rice denominator uses only yes and no choices. Abstentions, absences, and unknown values remain visible and are excluded from the binary score.' },
+    { question: 'Can agreement prove that two groups share an ideology?', answer: 'No. Agreement only describes recorded binary choices on comparable votes. It does not identify ideology, intent, collusion, or causation.' },
+    { question: 'Why does the analyzer show comparable vote counts?', answer: 'A percentage without its denominator can hide missing records. The comparable count shows how many shared votes contributed to each agreement rate.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'Prepare one row per choice', text: 'Create CSV rows with member, group, vote, and choice columns.' },
+    { name: 'Load the matrix', text: 'Paste the CSV or load the example, then check the group and vote counts.' },
+    { name: 'Read group cohesion', text: 'Use the ribbon and Rice Index summary to inspect binary cohesion.' },
+    { name: 'Compare choices', text: 'Switch between group and member agreement and read the comparable count.' },
+    { name: 'Review warnings', text: 'Investigate skipped rows, duplicates, unknown choices, ties, and low samples.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};
+
+export const englishContent: ParliamentaryVotingLocaleContent = content;

package/src/tool/parliamentary-voting-analyzer/i18n/es.ts

@@ -0,0 +1,49 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { ParliamentaryVotingLocaleContent } from '../entry';
+import type { ParliamentaryVotingUI } from '../ui';
+
+const ui: ParliamentaryVotingUI = {
+  dataHeading: 'Da visibilidad a una votación nominal', dataHelp: 'Pega una fila por miembro y votación. Usa cuatro columnas llamadas miembro, grupo, votación y opción.', csvLabel: 'CSV de votación nominal', csvHint: 'Columnas obligatorias: miembro, grupo, votación y opción. Opciones aceptadas: sí, no, abstención, ausencia y desconocido.', loadExample: 'Cargar ejemplo', analyzeAction: 'Analizar votos', clearAction: 'Borrar datos', compareLabel: 'Vista de acuerdo', groupsOption: 'Grupos', membersOption: 'Miembros', resultHeading: 'El registro de votación de un vistazo', emptyResult: 'Pega una votación o carga el ejemplo para revelar la cinta de votos.', rowsLabel: 'registros', groupsLabel: 'grupos', votesLabel: 'votaciones', warningsHeading: 'Comprobaciones antes de interpretar', methodHeading: 'Método aplicado', methodText: 'El índice de Rice de cada grupo y votación es la diferencia absoluta entre sí y no dividida por sí más no. Las abstenciones, ausencias y opciones desconocidas quedan fuera de ese denominador binario. Las medias de grupo son promedios no ponderados de las votaciones con al menos un sí o un no. El acuerdo compara opciones binarias en la misma votación y siempre muestra el número de votaciones comparables.', limitsHeading: 'Lo que esta herramienta no hace', limitsText: 'No infiere ideología, intención, disciplina, connivencia, mala conducta, posiciones políticas ni causalidad. Tampoco decide si una votación fue válida o si un miembro tenía obligación legal de asistir. Un voto parecido puede tener muchas explicaciones.', edgeHeading: 'Casos límite y avisos de datos', edgeText: 'Una votación unánime obtiene una puntuación de 1, no una prueba de disciplina. Los empates producen cohesión cero y se marcan aparte de las abstenciones. Los votos ausentes reducen la muestra comparable. Mantén visibles en los datos de origen los cambios de grupo, los identificadores duplicados y las opciones desconocidas.', cohesionHeading: 'Cinta de cohesión', cohesionHelp: 'Cada fila es un grupo. Una marca brillante es un sí, una oscura un no, una discontinua un empate, una hueca una abstención y una tenue una ausencia o un dato desconocido.', agreementHeading: 'Acuerdo por pares', agreementHelp: 'El acuerdo usa solo opciones sí y no comparables compartidas por ambas entidades. En la vista de grupos, cada grupo aporta su opción mayoritaria no empatada. Las abstenciones y no participaciones quedan fuera del numerador y del denominador.', groupLabel: 'Grupo', voteLabel: 'Votación', riceLabel: 'Índice de Rice', comparableLabel: 'Votaciones comparables', participationLabel: 'Opciones registradas', abstentionsLabel: 'abstenciones', absencesLabel: 'ausencias', unknownLabel: 'desconocidas', noComparableData: 'No hay opciones sí o no comparables', noDataWarning: 'No se encontraron registros utilizables. Añade valores de miembro, grupo, votación y opción.', malformedRowWarning: 'Se omitieron algunas filas porque faltaba un campo obligatorio.', duplicateWarning: 'Los pares duplicados de miembro y votación se conservaron una sola vez.', unknownChoiceWarning: 'Algunas opciones se conservaron como desconocidas porque no se reconocieron como sí, no, abstención o ausencia.', lowSampleWarning: 'Algunos acuerdos por pares tienen menos de dos votaciones comparables y no deben tratarse como patrones estables.', tieWarning: 'El empate de un grupo o entidad se excluyó de la comparación por grupos para esa votación.', importedMessage: 'Ejemplo cargado. Puedes editar las filas antes de analizar.', invalidCsvMessage: 'Los datos no se pudieron leer como un CSV basado en filas.', copyAction: 'Copiar resumen', copiedMessage: 'Resumen copiado al portapapeles.', copyFailure: 'No se pudo copiar. Selecciona el texto del resumen manualmente.',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Analizador de votaciones parlamentarias', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Analiza la cohesión y el acuerdo por pares en votaciones nominales parlamentarias a partir de una matriz transparente.', url: 'https://gamebob.dev/es/analizador-votaciones-parlamentarias', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: '¿Qué mide el índice de Rice?', acceptedAnswer: { '@type': 'Answer', text: 'Para un grupo y una votación, es la diferencia absoluta entre votos sí y no dividida por su suma. Va de cero cuando hay empate a uno cuando la votación binaria es unánime.' } },
+  { '@type': 'Question', name: '¿Se incluyen abstenciones y ausencias?', acceptedAnswer: { '@type': 'Answer', text: 'No. El denominador binario del índice de Rice solo usa opciones sí y no. Las abstenciones, ausencias y opciones desconocidas siguen visibles como señales de participación, pero quedan fuera de la puntuación binaria.' } },
+  { '@type': 'Question', name: '¿El acuerdo demuestra que dos grupos comparten ideología?', acceptedAnswer: { '@type': 'Answer', text: 'No. El acuerdo solo describe las opciones binarias registradas en las votaciones que pueden compararse. No identifica ideología, intención, connivencia ni causalidad.' } },
+  { '@type': 'Question', name: '¿Por qué se muestran recuentos comparables?', acceptedAnswer: { '@type': 'Answer', text: 'Un porcentaje sin denominador puede ocultar registros ausentes. El recuento comparable muestra cuántas votaciones compartidas contribuyeron realmente a cada tasa de acuerdo.' } },
+] };
+const howTo: HowTo = { '@type': 'HowTo', name: 'Analizar votaciones nominales parlamentarias', step: [
+  { '@type': 'HowToStep', name: 'Prepara una fila por opción', text: 'Crea filas CSV con las columnas miembro, grupo, votación y opción. Usa sí, no, abstención, ausencia o desconocido.' },
+  { '@type': 'HowToStep', name: 'Carga la matriz', text: 'Pega el CSV o carga el ejemplo y comprueba que los recuentos de grupos y votaciones coinciden con tu fuente.' },
+  { '@type': 'HowToStep', name: 'Lee la cohesión', text: 'Usa la cinta y el resumen del índice de Rice para examinar la cohesión binaria de cada grupo y votación.' },
+  { '@type': 'HowToStep', name: 'Compara opciones', text: 'Cambia entre acuerdo de grupos y de miembros, y lee cada tasa junto a su número de votaciones comparables.' },
+  { '@type': 'HowToStep', name: 'Revisa los avisos', text: 'Investiga filas omitidas, duplicados, opciones desconocidas, empates y muestras pequeñas antes de sacar conclusiones.' },
+] };
+const faqItems = (faqPage.mainEntity ?? []) as unknown as Array<{ name?: string; acceptedAnswer?: { text?: string } }>;
+const howToSteps = (howTo.step ?? []) as unknown as Array<{ name?: string; text?: string }>;
+
+export const content: ParliamentaryVotingLocaleContent = {
+  slug: 'analizador-votaciones-parlamentarias', title: 'Analizador de votaciones parlamentarias', description: 'Mide la cohesión de los grupos y el acuerdo por pares en una matriz de votaciones nominales, manteniendo visibles las abstenciones, ausencias, denominadores y advertencias.', ui,
+  seo: [
+    { type: 'title', text: 'Examina la cohesión de una votación nominal parlamentaria', level: 2 },
+    { type: 'paragraph', html: 'Una votación nominal registra quién votó, pero una lista larga de síes y noes no muestra de inmediato si un grupo actuó unido. Este analizador convierte una matriz por filas en una cinta visual, resúmenes por grupo y resultados de acuerdo por pares. Conserva las diferencias del registro para que un porcentaje atractivo no borre las ausencias ni las opciones no binarias.' },
+    { type: 'paragraph', html: 'La entrada prevista es una tabla con una fila por miembro y votación. Cada fila nombra al miembro, su grupo parlamentario, el identificador de la votación y la opción registrada. El analizador acepta etiquetas habituales como a favor, en contra, abstención y no votó; una opción no reconocida se conserva como desconocida en lugar de recodificarse en silencio.' },
+    { type: 'title', text: 'Cómo se calcula el índice de Rice', level: 2 },
+    { type: 'paragraph', html: 'Para un grupo en una votación, el índice de Rice es |sí menos no| dividido por sí más no. Una votación binaria unánime vale 1, un reparto exacto vale 0 y un grupo sin síes ni noes no tiene valor de Rice. El resumen del grupo es la media no ponderada de los valores disponibles, por lo que los datos binarios ausentes no se convierten en ceros inventados.' },
+    { type: 'table', headers: ['Señal', 'Cálculo', 'Interpretación'], rows: [['Índice de Rice', '|sí menos no| / (sí más no)', 'Cohesión binaria de un grupo y una votación'], ['Rice medio', 'Media de los valores disponibles', 'Cohesión habitual en votaciones comparables'], ['Acuerdo', 'Opciones binarias coincidentes / votaciones compartidas comparables', 'Coincidencia observada entre dos entidades']] },
+    { type: 'title', text: 'Prepara una matriz que se pueda comprobar', level: 2 },
+    { type: 'paragraph', html: 'Usa un identificador estable para cada votación y conserva las categorías originales hasta terminar la importación. No conviertas una ausencia en un no ni una abstención en una celda vacía. Esas decisiones cambian los recuentos de participación y el conjunto de observaciones comparables.' },
+    { type: 'list', items: ['Confirma que cada fila pertenece a la cámara y al periodo que quieres estudiar.', 'Mantén consistentes los nombres de miembros y grupos, incluidos acentos y signos de puntuación.', 'Asigna identificadores distintos a mociones repetidas cuando sean votaciones nominales separadas.', 'Comprueba los pares duplicados de miembro y votación con el registro original antes de aceptar la primera fila.', 'Guarda el archivo de origen y el texto importado exacto junto a cualquier interpretación publicada.'] },
+    { type: 'tip', title: 'Todo porcentaje necesita denominador', html: 'Un acuerdo por pares del 100 % en dos votaciones compartidas es una evidencia distinta del 100 % en ochenta. Lee el recuento comparable junto a cada tasa y trata una muestra pequeña como una invitación a reunir más datos, no como un patrón estable.' },
+    { type: 'title', text: 'Interpreta la cinta sin exagerar lo que demuestra', level: 2 },
+    { type: 'paragraph', html: 'La cinta ayuda a leer los datos, pero no emite un veredicto político. Las marcas azules representan la mayoría de síes del grupo, las rojizas una mayoría de noes, las marcas delineadas una abstención y las tenues una ausencia o un dato desconocido. La puntuación junto a la fila resume solo las opciones binarias; los recuentos de participación muestran qué quedó fuera del denominador.' },
+    { type: 'paragraph', html: 'Una cohesión alta puede surgir de preferencias compartidas, disciplina de partido, negociación de coalición, una moción muy concreta o un grupo pequeño. Un acuerdo alto entre dos grupos puede reflejar una agenda con poco desacuerdo. Una puntuación baja puede reflejar una división real o cambios en el registro de miembros. El analizador describe la matriz y no puede elegir entre esas explicaciones.' },
+    { type: 'title', text: 'Límites del método y avisos de datos', level: 2 },
+    { type: 'paragraph', html: 'La herramienta sigue el cálculo binario convencional de Rice y una regla transparente de acuerdo por pares. No infiere ideología, intención, mala conducta ni obligaciones legales. Comprueba las definiciones oficiales de la votación antes de tratar una abstención, ausencia u opción desconocida como comparable entre parlamentos.' },
+    { type: 'tip', title: 'Los avisos forman parte del resultado', html: 'Las filas omitidas, identificadores duplicados, opciones desconocidas, mayorías empatadas y muestras comparables pequeñas no son avisos decorativos. Resuélvelos o documéntalos antes de comparar periodos, grupos o miembros.' },
+  ],
+  faq: faqItems.map((item) => ({ question: String(item.name), answer: String(item.acceptedAnswer?.text) })), bibliography,
+  howTo: howToSteps.map((step) => ({ name: String(step.name), text: String(step.text) })), schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};

package/src/tool/parliamentary-voting-analyzer/i18n/fr.ts

@@ -0,0 +1,43 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { ParliamentaryVotingLocaleContent } from '../entry';
+import type { ParliamentaryVotingUI } from '../ui';
+
+const ui: ParliamentaryVotingUI = {
+  dataHeading: 'Donnez une forme visible à un vote nominal', dataHelp: 'Collez une ligne par membre et par vote. Utilisez les quatre colonnes membre, groupe, vote et choix.', csvLabel: 'CSV du vote nominal', csvHint: 'Colonnes obligatoires: membre, groupe, vote, choix. Choix acceptés: oui, non, abstention, absent, inconnu.', loadExample: "Charger l'exemple", analyzeAction: 'Analyser les votes', clearAction: 'Effacer les données', compareLabel: 'Vue des accords', groupsOption: 'Groupes', membersOption: 'Membres', resultHeading: 'Le relevé de vote en un coup d\'œil', emptyResult: "Collez un vote ou chargez l'exemple pour afficher le ruban des votes.", rowsLabel: 'enregistrements', groupsLabel: 'groupes', votesLabel: 'votes', warningsHeading: 'Vérifications avant interprétation', methodHeading: 'Méthode appliquée', methodText: "L'indice de Rice de chaque groupe et vote est la différence absolue entre oui et non, divisée par oui plus non. Les abstentions, absences et valeurs inconnues sont exclues de ce dénominateur binaire. Les moyennes de groupe sont des moyennes non pondérées des votes comportant au moins un oui ou un non. L'accord compare les choix binaires sur un même vote et affiche toujours le nombre de votes comparables.", limitsHeading: 'Ce que cet outil ne fait pas', limitsText: "Il n'infère ni idéologie, intention, discipline, entente, faute, position politique ni causalité. Il ne décide pas non plus si un vote était valide ou si un membre devait légalement être présent. Des votes similaires peuvent avoir plusieurs explications.", edgeHeading: 'Cas limites et avertissements', edgeText: "Un vote unanime obtient 1, mais cela ne prouve pas la discipline. Les égalités donnent une cohésion nulle et sont distinguées des abstentions. Les votes manquants réduisent l'échantillon comparable. Gardez visibles les changements de groupe, identifiants en double et choix inconnus dans les données sources.", cohesionHeading: 'Ruban de cohésion', cohesionHelp: 'Chaque ligne est un groupe. Une marque vive signifie oui, une sombre non, une tiretée égalité, une creuse abstention et une discrète absence ou donnée inconnue.', agreementHeading: 'Accord par paires', agreementHelp: "L'accord utilise uniquement les choix oui et non comparables partagés par les deux entités. Dans la vue des groupes, chaque groupe apporte son choix majoritaire non égalitaire. Les abstentions et non-participations restent hors du numérateur et du dénominateur.", groupLabel: 'Groupe', voteLabel: 'Vote', riceLabel: 'Indice de Rice', comparableLabel: 'Votes comparables', participationLabel: 'Choix enregistrés', abstentionsLabel: 'abstentions', absencesLabel: 'absences', unknownLabel: 'inconnus', noComparableData: 'Aucun choix oui ou non comparable', noDataWarning: "Aucun enregistrement utilisable. Ajoutez des valeurs pour le membre, le groupe, le vote et le choix.", malformedRowWarning: 'Certaines lignes ont été ignorées car un champ obligatoire était vide.', duplicateWarning: 'Les paires membre-vote en double n\'ont été conservées qu\'une fois.', unknownChoiceWarning: 'Certains choix sont restés inconnus car ils ne correspondaient pas à oui, non, abstention ou absence.', lowSampleWarning: 'Certains accords par paires ont moins de deux votes comparables et ne doivent pas être considérés comme stables.', tieWarning: 'Une égalité de groupe ou d\'entité a été exclue de la comparaison par groupes pour ce vote.', importedMessage: 'Exemple chargé. Vous pouvez modifier les lignes avant l\'analyse.', invalidCsvMessage: 'Les données ne peuvent pas être lues comme un CSV organisé par lignes.', copyAction: 'Copier le résumé', copiedMessage: 'Résumé copié dans le presse-papiers.', copyFailure: 'Échec de la copie. Sélectionnez manuellement le texte du résumé.',
+};
+const faq = [
+  { question: "Que mesure l'indice de Rice ?", answer: "Pour un groupe et un vote, c'est la différence absolue entre les votes oui et non divisée par leur somme. Il va de zéro pour une division égale à un pour un vote binaire unanime." },
+  { question: 'Les abstentions et absences sont-elles incluses ?', answer: "Non. Le dénominateur binaire de Rice utilise seulement oui et non. Les abstentions, absences et valeurs inconnues restent visibles comme signaux de participation, mais ne comptent pas dans le score binaire." },
+  { question: "L'accord prouve-t-il une idéologie commune ?", answer: "Non. Il décrit seulement les choix binaires enregistrés lors des votes comparables. Il n'identifie ni idéologie, intention, entente ni causalité." },
+  { question: 'Pourquoi afficher le nombre de votes comparables ?', answer: 'Un pourcentage sans dénominateur peut cacher des données manquantes. Ce nombre indique combien de votes partagés ont réellement contribué au taux d\'accord.' },
+];
+const howTo = [
+  { name: 'Préparer une ligne par choix', text: 'Créez des lignes CSV avec les colonnes membre, groupe, vote et choix. Utilisez oui, non, abstention, absent ou inconnu.' },
+  { name: 'Charger la matrice', text: "Collez le CSV ou chargez l'exemple, puis vérifiez les nombres de groupes et de votes par rapport à la source." },
+  { name: 'Lire la cohésion', text: "Utilisez le ruban et le résumé de l'indice de Rice pour examiner la cohésion binaire de chaque groupe et vote." },
+  { name: 'Comparer les choix', text: 'Passez de la comparaison des groupes à celle des membres et lisez chaque taux avec son nombre de votes comparables.' },
+  { name: 'Examiner les alertes', text: 'Vérifiez les lignes ignorées, doublons, choix inconnus, égalités et petits échantillons avant de conclure.' },
+];
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+const howToSchema: HowTo = { '@type': 'HowTo', name: 'Analyser des votes nominaux parlementaires', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) };
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Analyseur de votes parlementaires', applicationCategory: 'EducationalApplication', operatingSystem: 'Any', description: 'Analyse la cohésion et l\'accord par paires de votes nominaux parlementaires dans une matrice transparente.', url: 'https://gamebob.dev/fr/analyse-votes-parlementaires', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+
+export const content: ParliamentaryVotingLocaleContent = { slug: 'analyse-votes-parlementaires', title: 'Analyseur de votes parlementaires', description: 'Mesurez la cohésion des groupes et l\'accord par paires dans une matrice de votes nominaux, en gardant visibles abstentions, absences, dénominateurs et alertes.', ui, seo: [
+  { type: 'title', text: 'Examiner la cohésion d\'un vote nominal parlementaire', level: 2 },
+  { type: 'paragraph', html: 'Un vote nominal indique qui a voté, mais une longue liste de oui et de non ne montre pas immédiatement si un groupe a agi de façon unie. Cet analyseur transforme la matrice en lignes en ruban visuel, résumés de groupes et résultats d\'accord par paires. Il conserve les distinctions de la source pour éviter qu\'un pourcentage ne masque les absences ou choix non binaires.' },
+  { type: 'paragraph', html: 'L\'entrée attendue est un tableau contenant une ligne par membre et par vote. Chaque ligne donne le membre, le groupe parlementaire, l\'identifiant du vote et le choix enregistré. Les termes courants comme pour, contre, abstention et n\'a pas voté sont reconnus ; une valeur inconnue reste inconnue au lieu d\'être recodée en silence.' },
+  { type: 'title', text: 'Calculer l\'indice de Rice', level: 2 },
+  { type: 'paragraph', html: 'Pour un groupe et un vote, l\'indice de Rice est |oui moins non| divisé par oui plus non. Un vote binaire unanime vaut 1, un partage égal vaut 0 et un groupe sans oui ni non n\'a pas de valeur de Rice. Le résumé utilise la moyenne non pondérée des valeurs disponibles: les données manquantes ne deviennent pas des zéros inventés.' },
+  { type: 'table', headers: ['Signal', 'Calcul', 'Interprétation'], rows: [['Indice de Rice', '|oui moins non| / (oui plus non)', 'Cohésion binaire d\'un groupe et d\'un vote'], ['Rice moyen', 'Moyenne des valeurs disponibles', 'Cohésion habituelle des votes comparables'], ['Accord', 'Choix binaires identiques / votes partagés comparables', 'Coïncidence observée entre deux entités']] },
+  { type: 'title', text: 'Préparer une matrice vérifiable', level: 2 },
+  { type: 'paragraph', html: 'Employez un identifiant stable pour chaque vote et conservez les catégories originales jusqu\'à l\'import. Ne transformez pas une absence en non, ni une abstention en cellule vide: ces décisions modifient les comptes de participation et les observations comparables.' },
+  { type: 'list', items: ['Vérifiez que chaque ligne appartient à la chambre et à la période étudiées.', 'Gardez les noms des membres et groupes cohérents, accents et ponctuation compris.', 'Donnez des identifiants distincts aux motions répétées qui correspondent à des votes séparés.', 'Contrôlez les paires membre-vote en double avec la source avant de garder la première ligne.', 'Conservez le fichier source et le texte importé à côté de toute interprétation publiée.'] },
+  { type: 'tip', title: 'Un pourcentage a besoin de son dénominateur', html: 'Un accord de 100 % sur deux votes partagés n\'est pas la même preuve que 100 % sur quatre-vingts. Lisez le nombre comparable avec chaque taux et considérez un petit échantillon comme une raison de collecter davantage de données.' },
+  { type: 'title', text: 'Lire le ruban sans extrapoler', level: 2 },
+  { type: 'paragraph', html: 'Le ruban aide à lire les données, il ne rend pas de verdict politique. Les marques bleues représentent une majorité de oui, les marques rouille une majorité de non, les contours une abstention et les marques discrètes une absence ou une donnée inconnue. Le score résume les choix binaires ; les comptes de participation montrent ce qui est exclu du dénominateur.' },
+  { type: 'paragraph', html: 'Une forte cohésion peut venir de préférences communes, de la discipline de parti, d\'une négociation de coalition, d\'une motion étroite ou d\'un petit groupe. Un fort accord entre groupes peut refléter un ordre du jour peu conflictuel. Un score bas peut indiquer une division réelle ou une composition changeante. L\'outil décrit la matrice sans trancher entre ces explications.' },
+  { type: 'title', text: 'Limites de la méthode et alertes de données', level: 2 },
+  { type: 'paragraph', html: 'L\'outil applique le calcul binaire conventionnel de Rice et une règle transparente d\'accord par paires. Il n\'infère ni idéologie, intention, faute ni obligation légale. Consultez les définitions officielles du vote avant de comparer abstention, absence ou valeur inconnue entre parlements.' },
+  { type: 'tip', title: 'Les alertes font partie du résultat', html: 'Lignes ignorées, identifiants en double, choix inconnus, égalités et petits échantillons comparables ne sont pas décoratifs. Résolvez-les ou documentez-les avant de comparer périodes, groupes ou membres.' },
+], faq, bibliography, howTo, schemas: [softwareApplication, faqPage, howToSchema] as unknown as Record<string, unknown>[] };