@jjlmoya/utils-civic 1.3.0 → 1.5.0

package/src/tool/civic-priority-matrix/component.astro

@@ -0,0 +1,108 @@
+---
+import './civic-priority-matrix.css';
+import type { CivicPriorityUI } from './ui';
+import { defaultInitiatives } from './storage';
+
+interface Props {
+  ui: CivicPriorityUI;
+  locale: string;
+}
+
+const { ui, locale } = Astro.props;
+const exampleNames: Record<string, string[]> = {
+  de: ['Barrierefreie Bushaltestellen', 'Kühlzentren', 'Protokolle öffentlicher Sitzungen', 'Reparatur der Parkbeleuchtung'],
+  en: ['Accessible bus stops', 'Cooling centres', 'Public meeting transcripts', 'Park lighting repair'],
+  es: ['Paradas de autobús accesibles', 'Centros de refrigeración', 'Actas de reuniones públicas', 'Reparación del alumbrado del parque'],
+  fr: ['Arrêts de bus accessibles', 'Centres de rafraîchissement', 'Procès-verbaux des réunions publiques', 'Réparation de l\'éclairage du parc'],
+  id: ['Halte bus yang mudah diakses', 'Pusat penyejuk', 'Transkrip rapat publik', 'Perbaikan lampu taman'],
+  it: ['Fermate accessibili', 'Centri di raffrescamento', 'Verbali delle riunioni pubbliche', 'Riparazione delle luci del parco'],
+  ja: ['バリアフリーのバス停', 'クーリングセンター', '公開会議の議事録', '公園照明の修理'],
+  ko: ['접근 가능한 버스 정류장', '무더위 쉼터', '공개 회의록', '공원 조명 수리'],
+  nl: ['Toegankelijke bushaltes', 'Koelcentra', 'Verslagen van openbare bijeenkomsten', 'Reparatie van parkverlichting'],
+  pl: ['Dostępne przystanki autobusowe', 'Centra chłodzenia', 'Protokoły zebrań publicznych', 'Naprawa oświetlenia parku'],
+  pt: ['Paragens de autocarro acessíveis', 'Centros de arrefecimento', 'Atas de reuniões públicas', 'Reparação da iluminação do parque'],
+  ru: ['Доступные автобусные остановки', 'Центры охлаждения', 'Протоколы публичных собраний', 'Ремонт освещения в парке'],
+  sv: ['Tillgängliga busshållplatser', 'Kylcenter', 'Protokoll från offentliga möten', 'Reparation av parkbelysning'],
+  tr: ['Erişilebilir otobüs durakları', 'Serinleme merkezleri', 'Açık toplantı tutanakları', 'Park aydınlatması onarımı'],
+  zh: ['无障碍公交站', '避暑中心', '公开会议记录', '公园照明维修'],
+};
+const localizedInitiatives = defaultInitiatives.map((item, index) => ({
+  ...item,
+  name: exampleNames[locale]?.[index] ?? item.name,
+}));
+const stateJson = JSON.stringify({ initiatives: localizedInitiatives }).replace(/</g, '\\u003c');
+const uiJson = JSON.stringify(ui).replace(/</g, '\\u003c');
+---
+
+<section class="civic-priority-tool" data-civic-priority>
+  <div class="priority-main-surface">
+    <div class="priority-main-flow">
+      <div class="priority-control-surface">
+      <div class="priority-control-header">
+        <div>
+          <p class="priority-kicker">{ui.initiativeList}</p>
+          <p class="priority-input-hint">{ui.inputHint}</p>
+        </div>
+        <button class="priority-add" type="button" data-action="add">{ui.addInitiative}</button>
+      </div>
+      <div class="priority-scale-note">
+        <span>{ui.scoreScale}</span>
+        <span>{ui.scoreHint}</span>
+      </div>
+      <div class="priority-initiative-list" data-initiative-list></div>
+      <div class="priority-control-footer">
+        <button class="priority-reset" type="button" data-action="reset">{ui.reset}</button>
+        <p class="priority-form-status" data-priority-status aria-live="polite"></p>
+      </div>
+      </div>
+
+      <div class="priority-result-surface">
+      <div class="priority-result-heading">
+        <div>
+          <p class="priority-kicker">{ui.resultTitle}</p>
+          <p class="priority-summary" data-priority-summary aria-live="polite">{ui.emptyState}</p>
+        </div>
+      </div>
+      <div class="priority-scene-wrap">
+        <div class="priority-scene" data-priority-scene></div>
+        <div class="priority-legend" aria-label={ui.matrixLabel}>
+          <span><i class="priority-legend-dot priority-dot-plan"></i>{ui.plan}</span>
+          <span><i class="priority-legend-dot priority-dot-act"></i>{ui.actNow}</span>
+          <span><i class="priority-legend-dot priority-dot-defer"></i>{ui.defer}</span>
+          <span><i class="priority-legend-dot priority-dot-quick"></i>{ui.quickResponse}</span>
+        </div>
+      </div>
+      <div class="priority-ranking-block">
+        <h2>{ui.rankingTitle}</h2>
+        <div data-priority-ranking></div>
+      </div>
+      <div class="priority-warnings" data-priority-warnings aria-live="polite"></div>
+      </div>
+    </div>
+
+    <div class="priority-method-grid">
+      <article class="priority-method-card">
+        <h2>{ui.methodTitle}</h2>
+        <p>{ui.methodText}</p>
+      </article>
+      <article class="priority-method-card">
+        <h2>{ui.notDoTitle}</h2>
+        <p>{ui.notDoText}</p>
+      </article>
+      <article class="priority-method-card">
+        <h2>{ui.edgeCasesTitle}</h2>
+        <p>{ui.edgeCasesText}</p>
+      </article>
+    </div>
+  </div>
+</section>
+
+<script is:inline type="application/json" data-civic-priority-state set:html={stateJson}></script>
+<script is:inline type="application/json" data-civic-priority-ui set:html={uiJson}></script>
+<script>
+  import { mountCivicPriorityMatrix } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-civic-priority]');
+  const uiScript = document.querySelector<HTMLScriptElement>('[data-civic-priority-ui]');
+  if (root && uiScript) mountCivicPriorityMatrix(root, JSON.parse(uiScript.textContent ?? '{}'));
+</script>

package/src/tool/civic-priority-matrix/contract.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { civicPriorityMatrix } from './entry';
+import { CIVIC_PRIORITY_MATRIX_TOOL } from './index';
+
+describe('civic priority matrix runtime contract', () => {
+  it('exposes the English loader and page component loaders', async () => {
+    const content = await civicPriorityMatrix.i18n.en?.();
+
+    expect(content?.slug).toBe('civic-priority-matrix');
+    expect(content?.ui).toBeDefined();
+    expect(content?.seo.length).toBeGreaterThan(0);
+    expect(typeof CIVIC_PRIORITY_MATRIX_TOOL.Component).toBe('function');
+    expect(typeof CIVIC_PRIORITY_MATRIX_TOOL.SEOComponent).toBe('function');
+    expect(typeof CIVIC_PRIORITY_MATRIX_TOOL.BibliographyComponent).toBe('function');
+  });
+});

package/src/tool/civic-priority-matrix/controller.ts

@@ -0,0 +1,168 @@
+import { analyzeInitiatives, type InitiativeInput } from './logic';
+import { renderAnalysis } from './dom-views';
+import { defaultInitiatives, loadCivicPriorityState, saveCivicPriorityState, type CivicPriorityState } from './storage';
+import type { CivicPriorityUI } from './ui';
+
+function createId(): string {
+  return `initiative-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function inputElement(field: string, value: string, ui: CivicPriorityUI): HTMLInputElement {
+  const input = document.createElement('input');
+  input.className = 'priority-input';
+  input.dataset.field = field;
+  input.value = value;
+  input.setAttribute('aria-label', field === 'name' ? ui.initiative : field);
+  if (field !== 'name') {
+    input.type = 'number';
+    input.min = field === 'effort' ? '0' : '1';
+    input.max = '5';
+    input.step = '1';
+  }
+  return input;
+}
+
+function createField(label: string, input: HTMLInputElement): HTMLLabelElement {
+  const field = document.createElement('label');
+  field.className = 'priority-field-control';
+  const text = document.createElement('span');
+  text.textContent = label;
+  field.append(text, input);
+  return field;
+}
+
+function createRow(item: InitiativeInput, index: number, ui: CivicPriorityUI): HTMLElement {
+  const row = document.createElement('div');
+  row.className = 'priority-initiative-row';
+  row.dataset.initiativeRow = '';
+  row.dataset.index = String(index);
+  row.dataset.id = item.id;
+  row.append(
+    createField(ui.initiative, inputElement('name', item.name, ui)),
+    createField(ui.impact, inputElement('impact', String(item.impact), ui)),
+    createField(ui.urgency, inputElement('urgency', String(item.urgency), ui)),
+    createField(ui.effort, inputElement('effort', String(item.effort), ui)),
+  );
+  const remove = document.createElement('button');
+  remove.type = 'button';
+  remove.className = 'priority-remove';
+  remove.dataset.action = 'remove';
+  remove.textContent = '×';
+  remove.setAttribute('aria-label', ui.removeInitiative);
+  row.appendChild(remove);
+  const error = document.createElement('p');
+  error.className = 'priority-row-error';
+  error.dataset.rowError = '';
+  row.appendChild(error);
+  return row;
+}
+
+function renderRows(list: HTMLElement, initiatives: InitiativeInput[], ui: CivicPriorityUI): void {
+  list.replaceChildren(...initiatives.map((item, index) => createRow(item, index, ui)));
+}
+
+function readInputs(list: HTMLElement): InitiativeInput[] {
+  return Array.from(list.querySelectorAll<HTMLElement>('[data-initiative-row]')).map((row, index) => {
+    const read = (field: string): string => row.querySelector<HTMLInputElement>(`[data-field="${field}"]`)?.value ?? '';
+    return { id: row.dataset.id ?? `initiative-${index}`, name: read('name'), impact: Number(read('impact')), urgency: Number(read('urgency')), effort: Number(read('effort')) };
+  });
+}
+
+function markErrors(list: HTMLElement, analysis: ReturnType<typeof analyzeInitiatives>, ui: CivicPriorityUI): void {
+  list.querySelectorAll<HTMLElement>('[data-initiative-row]').forEach((row) => {
+    row.querySelectorAll<HTMLInputElement>('[data-field]').forEach((input) => input.removeAttribute('aria-invalid'));
+    const error = row.querySelector<HTMLElement>('[data-row-error]');
+    if (error) error.textContent = '';
+  });
+  analysis.errors.forEach((entry) => {
+    const row = list.querySelector<HTMLElement>(`[data-index="${entry.index}"]`);
+    const input = row?.querySelector<HTMLInputElement>(`[data-field="${entry.field}"]`);
+    input?.setAttribute('aria-invalid', 'true');
+    const error = row?.querySelector<HTMLElement>('[data-row-error]');
+    if (error && !error.textContent) error.textContent = errorMessage(entry.field, entry.message, ui);
+  });
+}
+
+function errorMessage(field: string, fallback: string, ui: CivicPriorityUI): string {
+  if (field === 'name') return ui.nameRequired;
+  if (field === 'impact') return ui.impactInvalid;
+  if (field === 'urgency') return ui.urgencyInvalid;
+  if (field === 'effort') return ui.effortInvalid;
+  return fallback;
+}
+
+function readInitialState(): CivicPriorityState {
+  const script = document.querySelector<HTMLScriptElement>('[data-civic-priority-state]');
+  try {
+    const parsed = script ? JSON.parse(script.textContent ?? '') as CivicPriorityState : null;
+    if (parsed && Array.isArray(parsed.initiatives)) return parsed;
+  } catch {
+    return { initiatives: defaultInitiatives };
+  }
+  return { initiatives: defaultInitiatives };
+}
+
+interface ActionContext {
+  targets: ReturnType<typeof getTargets>;
+  ui: CivicPriorityUI;
+  refresh: () => void;
+}
+
+function addInitiative(context: ActionContext): void {
+  const current = readInputs(context.targets.list);
+  current.push({ id: createId(), name: '', impact: 0, urgency: 0, effort: 0 });
+  renderRows(context.targets.list, current, context.ui);
+  context.refresh();
+}
+
+function removeInitiative(target: HTMLElement, context: ActionContext): void {
+  const row = target.closest<HTMLElement>('[data-initiative-row]');
+  const index = Number(row?.dataset.index ?? -1);
+  const current = readInputs(context.targets.list).filter((_item, itemIndex) => itemIndex !== index);
+  renderRows(context.targets.list, current, context.ui);
+  context.refresh();
+}
+
+function resetInitiatives(context: ActionContext): void {
+  const current = readInitialState().initiatives.map((item) => ({ ...item }));
+  renderRows(context.targets.list, current, context.ui);
+  context.refresh();
+}
+
+function handleClick(event: Event, context: ActionContext): void {
+  const target = event.target as HTMLElement;
+  const action = target.closest<HTMLElement>('[data-action]')?.dataset.action;
+  if (action === 'add') addInitiative(context);
+  if (action === 'remove') removeInitiative(target, context);
+  if (action === 'reset') resetInitiatives(context);
+}
+
+function getTargets(root: HTMLElement) {
+  const list = root.querySelector<HTMLElement>('[data-initiative-list]');
+  const scene = root.querySelector<HTMLElement>('[data-priority-scene]');
+  const summary = root.querySelector<HTMLElement>('[data-priority-summary]');
+  const ranking = root.querySelector<HTMLElement>('[data-priority-ranking]');
+  const warnings = root.querySelector<HTMLElement>('[data-priority-warnings]');
+  const status = root.querySelector<HTMLElement>('[data-priority-status]');
+  if (!list || !scene || !summary || !ranking || !warnings || !status) throw new Error('Civic priority matrix mount points are missing.');
+  return { list, scene, summary, ranking, warnings, status };
+}
+
+export function mountCivicPriorityMatrix(root: HTMLElement, ui: CivicPriorityUI): void {
+  const targets = getTargets(root);
+  let state = loadCivicPriorityState() ?? readInitialState();
+  renderRows(targets.list, state.initiatives, ui);
+
+  const refresh = (): void => {
+    state = { initiatives: readInputs(targets.list) };
+    const analysis = analyzeInitiatives(state.initiatives);
+    saveCivicPriorityState(state);
+    markErrors(targets.list, analysis, ui);
+    renderAnalysis(targets, analysis, ui);
+  };
+
+  root.addEventListener('input', refresh);
+  const context: ActionContext = { targets, ui, refresh };
+  root.addEventListener('click', (event) => handleClick(event, context));
+  refresh();
+}

package/src/tool/civic-priority-matrix/dom-views.ts

@@ -0,0 +1,123 @@
+import type { PriorityAnalysis, PriorityQuadrant, InitiativeResult } from './logic';
+import { getPriorityBadge } from './evaluator';
+import type { CivicPriorityUI } from './ui';
+
+interface ViewTargets {
+  scene: HTMLElement;
+  summary: HTMLElement;
+  ranking: HTMLElement;
+  warnings: HTMLElement;
+  status: HTMLElement;
+}
+
+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', { maximumFractionDigits: 2 }).format(value);
+}
+
+function quadrantLabel(ui: CivicPriorityUI, quadrant: PriorityQuadrant): string {
+  if (quadrant === 'act-now') return ui.actNow;
+  if (quadrant === 'plan') return ui.plan;
+  if (quadrant === 'quick-response') return ui.quickResponse;
+  return ui.defer;
+}
+
+function pointMarkup(item: InitiativeResult): string {
+  const x = 76 + ((item.impact - 1) / 4) * 368;
+  const y = 294 - ((item.urgency - 1) / 4) * 232;
+  const labelX = x > 340 ? x - 10 : x + 10;
+  const anchor = x > 340 ? 'end' : 'start';
+  const placeLabelAbove = y <= 64 || (y > 150 && y < 205);
+  const labelY = placeLabelAbove ? Math.max(12, y - 32) : y - 3;
+  return `<g class="priority-point priority-point-${item.quadrant}"><circle cx="${x}" cy="${y}" r="${Math.max(9, Math.min(18, 8 + item.priorityScore / 3))}"/><text x="${labelX}" y="${labelY}" text-anchor="${anchor}">${escapeHtml(item.normalizedName)} <tspan class="priority-point-score">(${number(item.priorityScore)})</tspan></text></g>`;
+}
+
+function renderScene(target: HTMLElement, analysis: PriorityAnalysis, ui: CivicPriorityUI): void {
+  if (!analysis.valid) {
+    const message = analysis.initiatives.length === 0 ? ui.noInitiatives : ui.invalidState;
+    target.innerHTML = `<div class="priority-empty"><span class="priority-empty-mark" aria-hidden="true"></span><p>${escapeHtml(message)}</p></div>`;
+    return;
+  }
+  const points = analysis.initiatives.map(pointMarkup).join('');
+  target.innerHTML = `<svg class="priority-field" viewBox="0 0 520 370" role="img" aria-label="${escapeHtml(ui.matrixLabel)}"><rect class="priority-quadrant priority-quadrant-plan" x="54" y="24" width="205" height="128" rx="18"/><rect class="priority-quadrant priority-quadrant-act" x="259" y="24" width="207" height="128" rx="18"/><rect class="priority-quadrant priority-quadrant-defer" x="54" y="152" width="205" height="128" rx="18"/><rect class="priority-quadrant priority-quadrant-quick" x="259" y="152" width="207" height="128" rx="18"/><path class="priority-axis" d="M54 152H466M259 24V280"/><text class="priority-axis-label" x="259" y="330" text-anchor="middle">${escapeHtml(ui.impact)}</text><text class="priority-axis-label" x="18" y="152" text-anchor="middle" transform="rotate(-90 18 152)">${escapeHtml(ui.urgency)}</text><text class="priority-axis-end" x="58" y="315">${escapeHtml(ui.lowImpact)}</text><text class="priority-axis-end" x="462" y="315" text-anchor="end">${escapeHtml(ui.highImpact)}</text><text class="priority-axis-end" x="42" y="276" text-anchor="end">${escapeHtml(ui.lowUrgency)}</text><text class="priority-axis-end" x="42" y="34" text-anchor="end">${escapeHtml(ui.highUrgency)}</text><text class="priority-quadrant-label" x="70" y="52">${escapeHtml(ui.plan)}</text><text class="priority-quadrant-label" x="275" y="52">${escapeHtml(ui.actNow)}</text><text class="priority-quadrant-label" x="70" y="180">${escapeHtml(ui.defer)}</text><text class="priority-quadrant-label" x="275" y="180">${escapeHtml(ui.quickResponse)}</text>${points}</svg>`;
+}
+
+function addCell(row: HTMLTableRowElement, text: string, className = ''): void {
+  const cell = document.createElement('td');
+  cell.textContent = text;
+  if (className) cell.className = className;
+  row.appendChild(cell);
+}
+
+function createHeaderRow(ui: CivicPriorityUI): HTMLTableRowElement {
+  const row = document.createElement('tr');
+  [ui.rank, ui.initiative, ui.priorityScore, ui.denominator, ui.quadrant].forEach((label) => addCell(row, label, 'priority-header-cell'));
+  return row;
+}
+
+function createRankingRow(item: InitiativeResult, index: number, ui: CivicPriorityUI): HTMLTableRowElement {
+  const row = document.createElement('tr');
+  row.dataset.quadrant = item.quadrant;
+  addCell(row, String(index + 1), 'priority-rank-cell');
+  addCell(row, item.normalizedName);
+  addCell(row, `${number(item.priorityScore)} ${ui.scoreOutOf}`);
+  addCell(row, `${item.denominator} (${ui.effort} ${item.effort})`);
+  const badge = document.createElement('span');
+  const badgeInfo = getPriorityBadge(item.quadrant);
+  badge.className = `priority-badge priority-badge-${badgeInfo.tone}`;
+  badge.textContent = quadrantLabel(ui, item.quadrant);
+  const quadrantCell = document.createElement('td');
+  quadrantCell.appendChild(badge);
+  row.appendChild(quadrantCell);
+  return row;
+}
+
+function renderRanking(target: HTMLElement, analysis: PriorityAnalysis, ui: CivicPriorityUI): void {
+  target.replaceChildren();
+  if (!analysis.valid) return;
+  const table = document.createElement('table');
+  table.className = 'priority-ranking-table';
+  const caption = document.createElement('caption');
+  caption.className = 'visually-hidden';
+  caption.textContent = ui.rankingTitle;
+  table.appendChild(caption);
+  const head = document.createElement('thead');
+  head.appendChild(createHeaderRow(ui));
+  table.appendChild(head);
+  const body = document.createElement('tbody');
+  analysis.initiatives.forEach((item, index) => body.appendChild(createRankingRow(item, index, ui)));
+  table.appendChild(body);
+  target.appendChild(table);
+}
+
+function renderWarnings(target: HTMLElement, analysis: PriorityAnalysis, ui: CivicPriorityUI): void {
+  target.replaceChildren();
+  analysis.warnings.forEach((warning) => {
+    const item = document.createElement('p');
+    item.className = 'priority-warning';
+    const message = warning.includes('effort score of 0') ? ui.zeroEffortWarning : ui.invalidRowsWarning;
+    item.innerHTML = `<strong>${escapeHtml(ui.warningTitle)}</strong> ${escapeHtml(message)}`;
+    target.appendChild(item);
+  });
+}
+
+function summaryText(analysis: PriorityAnalysis, ui: CivicPriorityUI): string {
+  if (analysis.valid) return `${ui.summaryPrefix} ${analysis.initiatives.length} ${ui.summarySuffix}.`;
+  if (analysis.initiatives.length === 0) return ui.noInitiatives;
+  return ui.emptyState;
+}
+
+function statusText(analysis: PriorityAnalysis, ui: CivicPriorityUI): string {
+  return analysis.valid || analysis.initiatives.length === 0 ? '' : ui.invalidState;
+}
+
+export function renderAnalysis(targets: ViewTargets, analysis: PriorityAnalysis, ui: CivicPriorityUI): void {
+  targets.summary.textContent = summaryText(analysis, ui);
+  targets.status.textContent = statusText(analysis, ui);
+  renderScene(targets.scene, analysis, ui);
+  renderRanking(targets.ranking, analysis, ui);
+  renderWarnings(targets.warnings, analysis, ui);
+}

package/src/tool/civic-priority-matrix/entry.ts

@@ -0,0 +1,28 @@
+import type { CivicToolEntry, ToolLocaleContent } from '../../types';
+import type { CivicPriorityUI } from './ui';
+
+export type { CivicPriorityUI } from './ui';
+export type CivicPriorityLocaleContent = ToolLocaleContent<CivicPriorityUI>;
+
+export const civicPriorityMatrix: CivicToolEntry<CivicPriorityUI> = {
+  id: 'civic-priority-matrix',
+  phase: 'localized',
+  icons: { bg: 'mdi:bank', fg: 'mdi:format-list-numbered' },
+  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/civic-priority-matrix/evaluator.ts

@@ -0,0 +1,13 @@
+import type { PriorityQuadrant } from './logic';
+
+export interface PriorityBadge {
+  key: 'actNow' | 'plan' | 'quickResponse' | 'defer';
+  tone: 'warm' | 'cool' | 'bright' | 'quiet';
+}
+
+export function getPriorityBadge(quadrant: PriorityQuadrant): PriorityBadge {
+  if (quadrant === 'act-now') return { key: 'actNow', tone: 'warm' };
+  if (quadrant === 'plan') return { key: 'plan', tone: 'cool' };
+  if (quadrant === 'quick-response') return { key: 'quickResponse', tone: 'bright' };
+  return { key: 'defer', tone: 'quiet' };
+}

package/src/tool/civic-priority-matrix/i18n/de.ts

@@ -0,0 +1,52 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CivicPriorityLocaleContent } from '../entry';
+import type { CivicPriorityUI } from '../ui';
+
+const ui: CivicPriorityUI = {
+  addInitiative: 'Vorhaben hinzufügen', initiativeList: 'Vorhaben bewerten', inputHint: 'Bewerte jeden Vorschlag auf derselben Skala von 1 bis 5.', initiative: 'Vorhaben', impact: 'Wirkung', urgency: 'Dringlichkeit', effort: 'Aufwand', scoreScale: 'Skala von 1 bis 5', scoreHint: 'Höher bedeutet mehr Wirkung, Dringlichkeit oder Aufwand.', removeInitiative: 'Vorhaben entfernen', reset: 'Beispiel zurücksetzen', resultTitle: 'Entscheidungsfeld', rankingTitle: 'Nachvollziehbare Reihenfolge', matrixLabel: 'Vorhaben nach Wirkung und Dringlichkeit', summaryPrefix: 'Angezeigt werden', summarySuffix: 'bewertete Vorhaben', rank: 'Rang', priorityScore: 'Prioritätswert', denominator: 'Aufwandsnenner', quadrant: 'Bereich', emptyState: 'Füge ein Vorhaben hinzu, um das Entscheidungsfeld zu öffnen.', invalidState: 'Korrigiere die markierten Werte, um eine Reihenfolge zu berechnen.', nameRequired: 'Name erforderlich.', impactInvalid: 'Wirkung muss eine ganze Zahl von 1 bis 5 sein.', urgencyInvalid: 'Dringlichkeit muss eine ganze Zahl von 1 bis 5 sein.', effortInvalid: 'Aufwand muss eine ganze Zahl von 0 bis 5 sein.', actNow: 'Jetzt handeln', plan: 'Planen', quickResponse: 'Schnell reagieren', defer: 'Zurückstellen', highImpact: 'Hohe Wirkung', lowImpact: 'Geringe Wirkung', highUrgency: 'Hohe Dringlichkeit', lowUrgency: 'Geringe Dringlichkeit', methodTitle: 'Angewandte Methode', methodText: 'Der Prioritätswert ist Wirkung mal Dringlichkeit geteilt durch Aufwand. Wirkung, Dringlichkeit und Aufwand nutzen eine sichtbare Skala von 1 bis 5. Aufwand 0 wird als 1 behandelt, damit eine kostenlose oder bereits vorbereitete Maßnahme einen endlichen Wert behält. Bei Gleichstand zählen Wirkung, Dringlichkeit, geringerer Aufwand und danach die Eingabereihenfolge.', notDoTitle: 'Was dieses Werkzeug nicht leistet', notDoText: 'Es bestimmt keinen objektiven gesellschaftlichen Wert, misst keine Ergebnisse automatisch und ersetzt keine Beratung. Ein hoher Wert ist ein nachvollziehbares Szenario unter deinen Annahmen, kein Auftrag und keine Vorhersage des Gemeinwohls.', edgeCasesTitle: 'Sonderfälle und Warnungen', edgeCasesText: 'Verwende für jede Zeile dieselbe Bedeutung der Werte. Ein fehlender oder nicht ganzzahliger Wert schließt die Zeile bis zur Korrektur aus. Der Wert 3 trennt hohe und niedrige Seiten. Gleiche Werte behalten nach den dokumentierten Regeln eine stabile Reihenfolge. Ändere in einer Gruppendiskussion jeweils nur eine Einschätzung.', warningTitle: 'Vor der Entscheidung prüfen', zeroEffortWarning: 'Aufwand 0 verwendet den Nenner 1, damit der Wert endlich und vergleichbar bleibt.', invalidRowsWarning: 'Einige Zeilen bleiben ausgeschlossen, bis die markierten Werte korrigiert sind.', noInitiatives: 'Noch keine Vorhaben eingegeben.', scoreOutOf: 'von maximal 25',
+};
+
+const softwareApplication: SoftwareApplication = { '@type': 'SoftwareApplication', name: 'Bürgerliche Prioritätsmatrix', applicationCategory: 'BusinessApplication', operatingSystem: 'Any', description: 'Bewerte bürgerschaftliche Vorhaben nach Wirkung, Dringlichkeit und Aufwand für eine nachvollziehbare Reihenfolge.', url: 'https://gamebob.dev/de/prioritaetsmatrix-buergerliche-vorhaben', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } };
+
+const faqPage: FAQPage = { '@type': 'FAQPage', mainEntity: [
+  { '@type': 'Question', name: 'Wie wird der Prioritätswert berechnet?', acceptedAnswer: { '@type': 'Answer', text: 'Multipliziere Wirkung und Dringlichkeit und teile durch den Aufwand. Aufwand 0 erhält den Nenner 1, damit kein unendlicher Wert entsteht.' } },
+  { '@type': 'Question', name: 'Was bedeutet die Position im Bereich?', acceptedAnswer: { '@type': 'Answer', text: 'Wirkung und Dringlichkeit von 3 bis 5 gelten als hoch. Die vier Bereiche geben Hinweise zum Handeln, Planen, schnellen Reagieren oder späteren Prüfen.' } },
+  { '@type': 'Question', name: 'Beweist ein hoher Wert, dass ein Vorhaben am besten ist?', acceptedAnswer: { '@type': 'Answer', text: 'Nein. Der Wert beschreibt nur die eingegebenen Annahmen. Er misst keinen objektiven gesellschaftlichen Nutzen und ersetzt keine Diskussion mit Betroffenen.' } },
+  { '@type': 'Question', name: 'Warum können zwei Vorhaben denselben Wert haben?', acceptedAnswer: { '@type': 'Answer', text: 'Verschiedene Kombinationen aus Wirkung, Dringlichkeit und Aufwand können denselben Quotienten ergeben. Danach gelten transparente Gleichstandsregeln.' } },
+] };
+
+const howTo: HowTo = { '@type': 'HowTo', name: 'Eine nachvollziehbare Prioritätenliste für Bürgerprojekte erstellen', step: [
+  { '@type': 'HowToStep', name: 'Vorhaben eintragen', text: 'Trage pro Zeile einen klar benannten Vorschlag ein und bündele keine voneinander abhängigen Maßnahmen.' },
+  { '@type': 'HowToStep', name: 'Skala gemeinsam festlegen', text: 'Definiere Wirkung, Dringlichkeit und Aufwand vor dem Vergleich und verwende die Skala in jeder Zeile gleich.' },
+  { '@type': 'HowToStep', name: 'Entscheidungsfeld lesen', text: 'Nutze die vier Bereiche als Gesprächsanstoß und prüfe, ob 3 konsequent als Grenze verwendet wird.' },
+  { '@type': 'HowToStep', name: 'Reihenfolge prüfen', text: 'Vergleiche jeden Wert mit seinen drei Eingaben und dem Aufwandsnenner, bevor du eine Schlussfolgerung ziehst.' },
+  { '@type': 'HowToStep', name: 'Entscheidung dokumentieren', text: 'Verwende die Liste als Tagesordnung und ergänze Belege, Zuständigkeiten, Einschränkungen und betroffene Stimmen.' },
+] };
+
+export const content: CivicPriorityLocaleContent = {
+  slug: 'prioritaetsmatrix-buergerliche-vorhaben', title: 'Bürgerliche Prioritätsmatrix', description: 'Ordne bürgerschaftliche Vorhaben mit transparenten Werten für Wirkung, Dringlichkeit und Aufwand. Erkenne, was jetzt handeln, planen, schnell reagieren oder später prüfen bedeutet.', ui,
+  seo: [
+    { type: 'title', text: 'Bürgerliche Ideen in eine gemeinsame Reihenfolge bringen', level: 2 },
+    { type: 'paragraph', html: 'Gruppen haben oft mehr gute Vorschläge als Zeit, Geld oder Mitarbeitende. Die Bürgerliche Prioritätsmatrix stellt jedem Vorhaben dieselben drei Fragen: Wie groß könnte die Wirkung sein, wie dringend ist das Problem und wie viel Aufwand braucht die Umsetzung? So entsteht ein sichtbarer Ausgangspunkt für ein Gespräch über Reihenfolge und verfügbare Kapazität.' },
+    { type: 'title', text: 'So funktioniert der Prioritätswert', level: 2 },
+    { type: 'paragraph', html: 'Der Wert lautet Wirkung mal Dringlichkeit geteilt durch Aufwand. Ein Vorhaben mit 5 Wirkung, 4 Dringlichkeit und 2 Aufwand erhält 10 Punkte. Das ist eine kompakte Heuristik, kein Maß für gesellschaftlichen Wert. Ihre Stärke liegt darin, dass jede Annahme sichtbar bleibt und andere Personen die Rechnung nachvollziehen können.' },
+    { type: 'table', headers: ['Eingabe', 'Skala', 'Frage für die Gruppe'], rows: [['Wirkung', '1 bis 5', 'Wie viel könnte die Veränderung für die betroffenen Menschen oder das Ergebnis bedeuten?'], ['Dringlichkeit', '1 bis 5', 'Was kostet das Warten oder welcher Zeitdruck besteht?'], ['Aufwand', '0 bis 5', 'Wie schwierig, teuer oder ressourcenintensiv ist die Umsetzung?']] },
+    { type: 'title', text: 'Die vier Entscheidungsbereiche lesen', level: 2 },
+    { type: 'paragraph', html: 'Das Feld ordnet Vorhaben nach Wirkung und Dringlichkeit. Der Wert 3 ist auf beiden Achsen die sichtbare Grenze. Jetzt handeln verbindet hohe Wirkung mit hoher Dringlichkeit. Planen beschreibt hohe Wirkung bei niedrigerer Dringlichkeit. Schnell reagieren weist auf niedrige Wirkung, aber hohe Dringlichkeit hin. Zurückstellen bedeutet niedrige Werte auf beiden Achsen und ist eine Einladung zur späteren Prüfung, keine automatische Ablehnung.' },
+    { type: 'list', items: ['Vereinbare zuerst, was Wirkung in dieser Gruppe bedeutet.', 'Verwende für alle Vorhaben denselben Zeithorizont bei der Dringlichkeit.', 'Bewerte Aufwand als benötigte Ressourcen, nicht als Beliebtheitsstrafe.', 'Lies neben jedem Rang auch die drei Einzelwerte.', 'Bewerte nach neuen Belegen, Fristen oder Kapazitätsänderungen erneut.'] },
+    { type: 'title', text: 'Das Ergebnis für eine bürgerschaftliche Diskussion nutzen', level: 2 },
+    { type: 'paragraph', html: 'Eine Matrix ist besonders hilfreich, wenn mehrere Personen dieselben Vorhaben bewerten und ihre Unterschiede erklären. Gibt eine Person einem kleinen, tief betroffenen Personenkreis hohe Wirkung und eine andere wegen der begrenzten Reichweite eine niedrigere, wird eine unklare Definition sichtbar. Halte die Gründe und die einbezogenen Stimmen fest, statt die Abweichung zu verstecken.' },
+    { type: 'tip', title: 'Der Wert ist ein erklärtes Szenario', html: 'Ein hoher Wert bedeutet, dass die eingegebene Kombination unter dieser Formel weit oben landet. Er begründet keine rechtliche Pflicht, beweist keine Fairness und ersetzt keine öffentliche Entscheidung. Bewahre die Begründungen neben jeder Entscheidung auf, die diese Reihenfolge nutzt.' },
+    { type: 'title', text: 'Grenzen und Sonderfälle', level: 2 },
+    { type: 'paragraph', html: 'Aufwand 0 wird mit dem Nenner 1 geschützt, damit kein unendlicher Wert entsteht. Fehlende, gebrochene oder außerhalb der Skala liegende Werte schließen eine Zeile aus, bis sie korrigiert sind. Gleiche Werte werden mit Wirkung, Dringlichkeit, geringerem Aufwand und stabiler Eingabereihenfolge geordnet. Ein Bereich ist außerdem keine Risikoanalyse: Dringende Vorhaben mit hoher Wirkung können weiterhin rechtliche, finanzielle, sicherheitsbezogene oder barrierefreie Prüfungen brauchen.' },
+  ],
+  faq: [
+    { question: 'Wie wird der Prioritätswert berechnet?', answer: 'Multipliziere Wirkung und Dringlichkeit und teile durch Aufwand. Bei Aufwand 0 wird der Nenner 1 verwendet.' },
+    { question: 'Was bedeutet die Position im Entscheidungsfeld?', answer: 'Wirkung und Dringlichkeit ab 3 liegen auf der hohen Seite. Die Bereiche helfen, die Reihenfolge gemeinsam zu besprechen.' },
+    { question: 'Ist ein hoher Wert ein Beweis für das beste Vorhaben?', answer: 'Nein. Er ist ein nachvollziehbares Ergebnis unter den gewählten Annahmen und keine Vorhersage des gesellschaftlichen Nutzens.' },
+    { question: 'Warum entstehen gleiche Werte?', answer: 'Unterschiedliche Eingabekombinationen können denselben Quotienten ergeben. Transparente Gleichstandsregeln halten die Reihenfolge reproduzierbar.' },
+  ], bibliography, howTo: [
+    { name: 'Vorhaben eintragen', text: 'Trage je Zeile einen klaren Vorschlag ein.' }, { name: 'Skala vereinbaren', text: 'Verwende die Bedeutung von 1 bis 5 in jeder Zeile gleich.' }, { name: 'Feld lesen', text: 'Nutze die vier Bereiche als Gesprächsrahmen für die Reihenfolge.' }, { name: 'Rang prüfen', text: 'Vergleiche jede Platzierung mit Wirkung, Dringlichkeit, Aufwand und Nenner.' }, { name: 'Belege ergänzen', text: 'Dokumentiere nach der Diskussion Belege, Grenzen und betroffene Stimmen.' },
+  ], schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};

package/src/tool/civic-priority-matrix/i18n/en.ts

@@ -0,0 +1,73 @@
+import type { FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { CivicPriorityLocaleContent } from '../entry';
+import { ui } from '../ui';
+
+const softwareApplication: SoftwareApplication = {
+  '@type': 'SoftwareApplication',
+  name: 'Civic Priority Matrix',
+  applicationCategory: 'BusinessApplication',
+  operatingSystem: 'Any',
+  description: 'Score civic initiatives by impact, urgency, and effort to create an explainable priority order.',
+  url: 'https://gamebob.dev/en/civic-priority-matrix',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+};
+
+const faqPage: FAQPage = {
+  '@type': 'FAQPage',
+  mainEntity: [
+    { '@type': 'Question', name: 'How is the priority score calculated?', acceptedAnswer: { '@type': 'Answer', text: 'The score is impact multiplied by urgency, divided by effort. Each score uses a 1 to 5 scale. Effort 0 uses a denominator of 1 so the result stays finite and its assumption remains visible.' } },
+    { '@type': 'Question', name: 'What does the quadrant position mean?', acceptedAnswer: { '@type': 'Answer', text: 'The field uses impact and urgency only. Scores of 3, 4, or 5 are placed on the high side of an axis, while 1 or 2 are placed on the low side. The zones suggest act now, plan, quick response, or defer.' } },
+    { '@type': 'Question', name: 'Does a high score prove that an initiative is best?', acceptedAnswer: { '@type': 'Answer', text: 'No. A high score is the result of the assumptions entered by the group. It does not measure objective social value, predict outcomes, or replace discussion with affected people.' } },
+    { '@type': 'Question', name: 'Why can two initiatives have the same rank score?', acceptedAnswer: { '@type': 'Answer', text: 'Different combinations of impact, urgency, and effort can produce the same quotient. The tool then uses impact, urgency, lower effort, and stable input order as transparent tie breakers.' } },
+  ],
+};
+
+const howTo: HowTo = {
+  '@type': 'HowTo',
+  name: 'Build an explainable civic priority order',
+  step: [
+    { '@type': 'HowToStep', name: 'List the initiatives', text: 'Enter one clearly named proposal per row. Avoid combining several actions in one item because the group cannot score a bundle consistently.' },
+    { '@type': 'HowToStep', name: 'Agree the scoring scale', text: 'Use the same meaning for impact, urgency, and effort across every row. Treat 1 as low and 5 as high, and use 0 effort only when no effort is being declared.' },
+    { '@type': 'HowToStep', name: 'Review the decision field', text: 'Read the quadrant as a conversation prompt: act now, plan, quick response, or defer. Check whether a score of 3 is being used consistently as the dividing line.' },
+    { '@type': 'HowToStep', name: 'Inspect the order', text: 'Compare each priority score with its three inputs and the effort denominator. A surprising rank is a reason to revisit an assumption, not to hide the result.' },
+    { '@type': 'HowToStep', name: 'Record the decision', text: 'Use the ranked list as an agenda for group discussion, then add evidence, owners, constraints, and affected voices before committing resources.' },
+  ],
+};
+
+export const content: CivicPriorityLocaleContent = {
+  slug: 'civic-priority-matrix',
+  title: 'Civic Priority Matrix',
+  description: 'Rank civic initiatives with a transparent impact, urgency, and effort score. See which proposals deserve action now, planning, a quick response, or a later review.',
+  ui,
+  seo: [
+    { type: 'title', text: 'Turn Civic Ideas Into a Shared Priority Order', level: 2 },
+    { type: 'paragraph', html: 'Groups often have more useful proposals than time, money, or people to act on them. The Civic Priority Matrix gives each initiative the same three questions: how much impact could it have, how urgent is the problem, and how much effort would implementation require? The result is a visible starting point for a conversation about sequence and trade offs.' },
+    { type: 'title', text: 'How the Priority Score Works', level: 2 },
+    { type: 'paragraph', html: 'The score is impact multiplied by urgency, divided by effort. For example, an initiative scored 5 for impact, 4 for urgency, and 2 for effort receives 10 points. The score is a compact heuristic, not a measurement of social value. It is useful because every component stays visible and another person can reproduce the arithmetic.' },
+    { type: 'table', headers: ['Input', 'Scale', 'Question to ask'], rows: [['Impact', '1 to 5', 'How much could this change matter to the people or outcome concerned?'], ['Urgency', '1 to 5', 'What is the cost of waiting or the time pressure?'], ['Effort', '0 to 5', 'How difficult, expensive, or resource intensive is delivery?']] },
+    { type: 'title', text: 'Read the Four Decision Zones', level: 2 },
+    { type: 'paragraph', html: 'The field positions initiatives by impact and urgency, with 3 as the dividing line on both axes. Act now contains high impact and high urgency items. Plan contains high impact items with lower urgency. Quick response contains lower impact items with high urgency, where a small intervention may still remove pressure. Defer contains items that are low on both axes and need a later review rather than automatic rejection.' },
+    { type: 'list', items: ['Agree what impact means for this specific group before entering scores.', 'Use the same time horizon when judging urgency across all initiatives.', 'Treat effort as the resources needed to deliver, not as a penalty for an unpopular idea.', 'Read the three component values beside every rank before discussing the order.', 'Re-score after new evidence, a deadline change, or a change in available capacity.'] },
+    { type: 'title', text: 'Make the Result Useful in a Civic Discussion', level: 2 },
+    { type: 'paragraph', html: 'A matrix is strongest when several people score the same initiatives and explain their differences. If one person gives an item high impact because it affects a small group deeply, while another gives it a lower score because the reach is limited, the disagreement reveals a criterion that needs definition. Record the reasons and the voices that informed the final choice.' },
+    { type: 'tip', title: 'The score is a declared scenario', html: 'A high result means that the entered combination of impact, urgency, and effort rises to the top under this formula. It does not establish a legal duty, prove fairness, forecast outcomes, or replace a public decision process. Keep the scoring notes beside any decision that uses the ranking.' },
+    { type: 'title', text: 'Limits and Edge Cases', level: 2 },
+    { type: 'paragraph', html: 'Effort 0 is protected with a denominator of 1 so it does not create an infinite result. A missing, fractional, or out of range value excludes that row until it is fixed. Equal scores are not silently rearranged: the tool applies documented tie breakers and then preserves input order. A quadrant is also not a risk assessment; urgent and high impact work may still need safety, legal, financial, or accessibility review.' },
+  ],
+  faq: [
+    { question: 'How is the priority score calculated?', answer: 'Multiply impact by urgency and divide by effort. An effort of 0 uses a denominator of 1 so the score stays finite.' },
+    { question: 'What does the quadrant position mean?', answer: 'Impact and urgency of 3 or more are on the high side. The four zones suggest act now, plan, quick response, or defer.' },
+    { question: 'Does a high score prove that an initiative is best?', answer: 'No. It is a transparent result under declared assumptions, not proof of social value or a prediction.' },
+    { question: 'Why can two initiatives have the same score?', answer: 'Different input combinations can produce the same quotient. The tool then uses transparent tie breakers and stable input order.' },
+  ],
+  bibliography,
+  howTo: [
+    { name: 'List the initiatives', text: 'Enter one clearly named proposal per row.' },
+    { name: 'Agree the scale', text: 'Use the same meaning for 1 to 5 across every row.' },
+    { name: 'Read the field', text: 'Use the four zones to frame the discussion around sequence.' },
+    { name: 'Inspect the order', text: 'Compare every rank with impact, urgency, effort, and the denominator.' },
+    { name: 'Add evidence', text: 'Use the result as an agenda, then record constraints and affected voices.' },
+  ],
+  schemas: [softwareApplication, faqPage, howTo] as unknown as Record<string, unknown>[],
+};