@jjlmoya/utils-pets 1.17.0 → 1.19.0

package/src/tool/petToxicity/component.astro

@@ -0,0 +1,53 @@
+---
+import './pet-food-toxicity-checker.css';
+import { getFoodEvaluation } from './logic';
+import { renderFoodMenu, renderResult, renderScene, renderSpeciesMenu } from './dom-views';
+import { petToxicity } from './entry';
+
+const content = await petToxicity.i18n.en?.();
+if (!content) return null;
+const { ui } = content;
+const defaultSpecies = 'dog';
+const defaultFood = 'chocolate';
+const evaluation = getFoodEvaluation(defaultSpecies, defaultFood);
+const config = { ui, defaultSpecies, defaultFood };
+---
+
+<section class="pet-toxicity" data-pet-toxicity-root aria-label={content.title}>
+  <div class="pet-toxicity-journey">
+    <span class="pet-toxicity-journey-mark" aria-hidden="true">!</span>
+    <p>{ui.journeyHint}</p>
+  </div>
+  <div class="pet-toxicity-workbench">
+    <div class="pet-toxicity-controls">
+      <div class="pet-toxicity-control">
+        <span class="pet-toxicity-label">{ui.speciesLabel}</span>
+        <div class="pet-toxicity-select">
+          <button class="pet-toxicity-select-trigger" type="button" data-menu-trigger data-species-trigger aria-haspopup="listbox" aria-expanded="false"><span data-trigger-value>{ui.speciesDog}</span><span class="pet-toxicity-chevron" aria-hidden="true"></span></button>
+          <div class="pet-toxicity-menu" data-menu data-species-menu role="listbox" hidden>{renderSpeciesMenu(defaultSpecies, ui)}</div>
+        </div>
+      </div>
+      <div class="pet-toxicity-control">
+        <span class="pet-toxicity-label">{ui.foodLabel}</span>
+        <div class="pet-toxicity-select">
+          <button class="pet-toxicity-select-trigger" type="button" data-menu-trigger data-food-trigger aria-haspopup="listbox" aria-expanded="false"><span data-trigger-value>{getFoodEvaluation(defaultSpecies, defaultFood)?.food.name ?? ui.foodPlaceholder}</span><span class="pet-toxicity-chevron" aria-hidden="true"></span></button>
+          <div class="pet-toxicity-menu" data-menu data-food-menu role="listbox" hidden>{renderFoodMenu([{ id: 'chocolate', name: 'Chocolate and caffeine', detail: 'Chocolate, coffee, tea, energy drinks' }], defaultFood)}</div>
+        </div>
+        <small class="pet-toxicity-hint">{ui.foodMenuHint}</small>
+      </div>
+    </div>
+    <div class="pet-toxicity-visual" data-scene>{renderScene(defaultSpecies, evaluation, ui)}</div>
+  </div>
+  <div class="pet-toxicity-result" data-result aria-live="polite">{renderResult(evaluation, ui)}</div>
+  <div class="pet-toxicity-emergency"><strong>{ui.emergencyTitle}</strong><span>{ui.emergencyText}</span></div>
+  <div class="pet-toxicity-sources"><span class="pet-toxicity-label">{ui.sourceLabel}</span><p>{ui.sourceText}</p></div>
+</section>
+
+<script is:inline type="application/json" data-pet-toxicity-config set:html={JSON.stringify(config)}></script>
+<script>
+  import { mountPetToxicity } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-pet-toxicity-root]');
+  const configElement = document.querySelector<HTMLScriptElement>('[data-pet-toxicity-config]');
+  if (root && configElement?.textContent) mountPetToxicity(root, JSON.parse(configElement.textContent));
+</script>

package/src/tool/petToxicity/controller.ts

@@ -0,0 +1,117 @@
+import { getFoodEvaluation, getFoodOptions } from './logic';
+import type { FoodId, PetSpecies } from './logic';
+import { renderFoodMenu, renderResult, renderScene, renderSpeciesMenu } from './dom-views';
+import { loadSavedState, saveState } from './storage';
+import type { PetToxicityUI } from './ui';
+
+interface MountPayload {
+  ui: PetToxicityUI;
+  defaultSpecies: PetSpecies;
+  defaultFood: FoodId;
+}
+
+interface ToolState {
+  species: PetSpecies;
+  foodId: FoodId;
+}
+
+function findElement<T extends Element>(root: HTMLElement, selector: string): T {
+  const element = root.querySelector<T>(selector);
+  if (!element) throw new Error(`Missing pet toxicity element: ${selector}`);
+  return element;
+}
+
+function closeMenus(root: HTMLElement): void {
+  root.querySelectorAll<HTMLElement>('[data-menu]').forEach((menu) => { menu.hidden = true; });
+  root.querySelectorAll<HTMLElement>('[data-menu-trigger]').forEach((trigger) => { trigger.setAttribute('aria-expanded', 'false'); });
+}
+
+function toggleMenu(root: HTMLElement, menu: HTMLElement, trigger: HTMLElement): void {
+  const shouldOpen = menu.hidden;
+  closeMenus(root);
+  menu.hidden = !shouldOpen;
+  trigger.setAttribute('aria-expanded', String(shouldOpen));
+}
+
+function labelForSpecies(species: PetSpecies, ui: PetToxicityUI): string {
+  return species === 'dog' ? ui.speciesDog : ui.speciesCat;
+}
+
+function setupKeyboard(root: HTMLElement): void {
+  root.querySelectorAll<HTMLElement>('[data-menu-trigger]').forEach((trigger) => {
+    trigger.addEventListener('keydown', (event) => {
+      if (event.key === 'Enter' || event.key === ' ') {
+        event.preventDefault();
+        trigger.click();
+      }
+      if (event.key === 'Escape') closeMenus(root);
+    });
+  });
+}
+
+interface ViewElements {
+  speciesTrigger: HTMLButtonElement;
+  speciesMenu: HTMLElement;
+  foodTrigger: HTMLButtonElement;
+  foodMenu: HTMLElement;
+  scene: HTMLElement;
+  result: HTMLElement;
+}
+
+function renderState(elements: ViewElements, state: ToolState, payload: MountPayload): void {
+  const options = getFoodOptions(state.species);
+  if (!options.some((option) => option.id === state.foodId)) state.foodId = options[0]?.id ?? payload.defaultFood;
+  const evaluation = getFoodEvaluation(state.species, state.foodId);
+  const selectedFood = options.find((option) => option.id === state.foodId);
+  elements.speciesTrigger.querySelector('[data-trigger-value]')!.textContent = labelForSpecies(state.species, payload.ui);
+  elements.foodTrigger.querySelector('[data-trigger-value]')!.textContent = selectedFood?.name ?? payload.ui.foodPlaceholder;
+  elements.speciesMenu.innerHTML = renderSpeciesMenu(state.species, payload.ui);
+  elements.foodMenu.innerHTML = renderFoodMenu(options, state.foodId);
+  elements.scene.innerHTML = renderScene(state.species, evaluation, payload.ui);
+  elements.result.innerHTML = renderResult(evaluation, payload.ui);
+  saveState(state);
+}
+
+function bindSelection(root: HTMLElement, elements: ViewElements, state: ToolState, render: () => void): void {
+  elements.speciesTrigger.addEventListener('click', () => toggleMenu(root, elements.speciesMenu, elements.speciesTrigger));
+  elements.foodTrigger.addEventListener('click', () => toggleMenu(root, elements.foodMenu, elements.foodTrigger));
+  root.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    const speciesOption = target.closest<HTMLElement>('[data-species-id]');
+    const foodOption = target.closest<HTMLElement>('[data-food-id]');
+    if (speciesOption) selectSpecies(speciesOption, root, state, render);
+    if (foodOption) selectFood(foodOption, root, state, render);
+  });
+  document.addEventListener('click', (event) => {
+    if (!root.contains(event.target as Node)) closeMenus(root);
+  });
+}
+
+function selectSpecies(option: HTMLElement, root: HTMLElement, state: ToolState, render: () => void): void {
+  state.species = option.dataset.speciesId as PetSpecies;
+  closeMenus(root);
+  render();
+}
+
+function selectFood(option: HTMLElement, root: HTMLElement, state: ToolState, render: () => void): void {
+  state.foodId = option.dataset.foodId as FoodId;
+  closeMenus(root);
+  render();
+}
+
+export function mountPetToxicity(root: HTMLElement, payload: MountPayload): void {
+  const saved = loadSavedState();
+  const state: ToolState = { species: saved?.species ?? payload.defaultSpecies, foodId: saved?.foodId ?? payload.defaultFood };
+  const elements: ViewElements = {
+    speciesTrigger: findElement<HTMLButtonElement>(root, '[data-species-trigger]'),
+    speciesMenu: findElement<HTMLElement>(root, '[data-species-menu]'),
+    foodTrigger: findElement<HTMLButtonElement>(root, '[data-food-trigger]'),
+    foodMenu: findElement<HTMLElement>(root, '[data-food-menu]'),
+    scene: findElement<HTMLElement>(root, '[data-scene]'),
+    result: findElement<HTMLElement>(root, '[data-result]'),
+  };
+  const render = () => renderState(elements, state, payload);
+  bindSelection(root, elements, state, render);
+  setupKeyboard(root);
+  render();
+}

package/src/tool/petToxicity/dom-views.ts

@@ -0,0 +1,61 @@
+import { getRiskPresentation } from './evaluator';
+import type { RiskTone } from './evaluator';
+import type { FoodEvaluation, FoodOption, PetSpecies } from './logic';
+import type { PetToxicityUI } from './ui';
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] ?? character);
+}
+
+function selectedAttribute(selected: boolean): string {
+  return selected ? ' aria-selected="true" data-selected="true"' : ' aria-selected="false"';
+}
+
+export function renderSpeciesMenu(species: PetSpecies, ui: PetToxicityUI): string {
+  const options = [
+    { id: 'dog', name: ui.speciesDog, detail: ui.speciesDogMeta },
+    { id: 'cat', name: ui.speciesCat, detail: ui.speciesCatMeta },
+  ];
+  return options.map((option) => `<button class="pet-toxicity-menu-option" type="button" role="option" data-species-id="${option.id}"${selectedAttribute(option.id === species)}><span>${escapeHtml(option.name)}</span><small>${escapeHtml(option.detail)}</small></button>`).join('');
+}
+
+export function renderFoodMenu(options: FoodOption[], selectedId: string): string {
+  return options.map((option) => `<button class="pet-toxicity-menu-option" type="button" role="option" data-food-id="${option.id}"${selectedAttribute(option.id === selectedId)}><span>${escapeHtml(option.name)}</span><small>${escapeHtml(option.detail)}</small></button>`).join('');
+}
+
+function renderMarkers(evaluation: FoodEvaluation | null): string {
+  const tone = evaluation?.level ?? 'empty';
+  const markerClass = evaluation ? `pet-toxicity-marker pet-toxicity-marker-${tone}` : 'pet-toxicity-marker pet-toxicity-marker-empty';
+  return [0, 1, 2, 3, 4].map((index) => `<circle class="${markerClass}" cx="${74 + index * 47}" cy="${82 + (index % 2) * 34}" r="${evaluation ? 7 + index : 5}" />`).join('');
+}
+
+export function renderScene(species: PetSpecies, evaluation: FoodEvaluation | null, ui: PetToxicityUI): string {
+  const speciesName = species === 'dog' ? ui.speciesDog : ui.speciesCat;
+  const selectedName = evaluation?.food.name ?? ui.sceneReady;
+  const stateText = evaluation ? ui.sceneSelected : ui.resultEmpty;
+  return `<div class="pet-toxicity-scene-card"><div class="pet-toxicity-scene-copy"><span class="pet-toxicity-eyebrow">${escapeHtml(ui.sceneLabel)}</span><strong>${escapeHtml(selectedName)}</strong><span>${escapeHtml(speciesName)} · ${escapeHtml(stateText)}</span></div><svg class="pet-toxicity-scene" viewBox="0 0 320 180" role="img" aria-label="${escapeHtml(selectedName)} risk scene"><rect class="pet-toxicity-scene-paper" x="14" y="14" width="292" height="152" rx="18" /><path class="pet-toxicity-scene-line" d="M38 122 C80 46 124 146 166 66 S246 50 282 118" /><path class="pet-toxicity-scene-line-thin" d="M42 138 C92 84 132 138 174 98 S240 82 280 136" />${renderMarkers(evaluation)}<circle class="pet-toxicity-scene-seal" cx="258" cy="52" r="20" /><path class="pet-toxicity-scene-seal-mark" d="M258 43v12" /><circle class="pet-toxicity-scene-seal-dot" cx="258" cy="62" r="1.7" /></svg></div>`;
+}
+
+function renderSignIcon(index: number): string {
+  const paths = [
+    '<circle cx="8" cy="8" r="6" /><path d="M8 4.5v4" /><circle cx="8" cy="11.5" r=".7" />',
+    '<path d="M1.5 9h2.5l1.5-4 2.5 6 1.6-3h2.3" />',
+    '<path d="m8 1.5 6 11H2l6-11Z" /><path d="M8 5v3" /><circle cx="8" cy="10.5" r=".7" />',
+  ];
+  return `<svg viewBox="0 0 16 16" aria-hidden="true" focusable="false">${paths[index % paths.length]}</svg>`;
+}
+
+function renderList(items: string[]): string {
+  return `<ul class="pet-toxicity-sign-list">${items.map((item, index) => `<li><span class="pet-toxicity-sign-icon">${renderSignIcon(index)}</span><span>${escapeHtml(item)}</span></li>`).join('')}</ul>`;
+}
+
+function renderRiskMeter(tone: RiskTone, label: string): string {
+  const activeCount = { critical: 3, high: 2, caution: 1, unknown: 0 }[tone];
+  return `<span class="pet-toxicity-risk-meter" role="img" aria-label="${escapeHtml(label)}"><span class="${activeCount >= 1 ? 'is-active' : ''}"></span><span class="${activeCount >= 2 ? 'is-active' : ''}"></span><span class="${activeCount >= 3 ? 'is-active' : ''}"></span></span>`;
+}
+
+export function renderResult(evaluation: FoodEvaluation | null, ui: PetToxicityUI): string {
+  if (!evaluation) return `<div class="pet-toxicity-result-empty">${escapeHtml(ui.resultEmpty)}</div>`;
+  const risk = getRiskPresentation(evaluation.level, ui);
+  return `<article class="pet-toxicity-result-card pet-toxicity-result-card-${risk.tone}"><div class="pet-toxicity-result-head"><span class="pet-toxicity-eyebrow">${escapeHtml(ui.resultEyebrow)}</span><span class="pet-toxicity-risk-status"><span class="pet-toxicity-risk pet-toxicity-risk-${risk.tone}">${escapeHtml(risk.label)}</span>${renderRiskMeter(risk.tone, `${ui.riskLabel}: ${risk.label}`)}</span></div><h3>${escapeHtml(evaluation.food.name)}</h3><p class="pet-toxicity-summary">${escapeHtml(evaluation.summary)}</p><div class="pet-toxicity-result-grid"><div><span class="pet-toxicity-label">${escapeHtml(ui.whyLabel)}</span><p>${escapeHtml(evaluation.why)}</p></div><div><span class="pet-toxicity-label">${escapeHtml(ui.signsLabel)}</span>${renderList(evaluation.signs)}</div><div class="pet-toxicity-action"><span class="pet-toxicity-label">${escapeHtml(ui.actionLabel)}</span><p>${escapeHtml(evaluation.action)}</p></div></div><div class="pet-toxicity-callout"><strong>${escapeHtml(ui.callVetLabel)}</strong><span>${escapeHtml(ui.callVetText)}</span></div></article>`;
+}

package/src/tool/petToxicity/entry.ts

@@ -0,0 +1,33 @@
+import type { PetToolEntry, ToolLocaleContent } from '../../types';
+import type { PetToxicityUI } from './ui';
+
+export type { PetToxicityUI } from './ui';
+
+export type PetToxicityLocaleContent = ToolLocaleContent<PetToxicityUI>;
+
+export const petToxicity: PetToolEntry<PetToxicityUI> = {
+  id: 'pet-toxicity',
+  icons: {
+    bg: 'mdi:paw',
+    fg: 'mdi:alert-octagon',
+  },
+  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),
+  },
+};
+
+export { bibliography } from './bibliography';

package/src/tool/petToxicity/evaluator.ts

@@ -0,0 +1,23 @@
+import type { PetToxicityUI } from './ui';
+import type { FoodEvaluation, RiskLevel } from './logic';
+
+export type RiskTone = 'critical' | 'high' | 'caution' | 'unknown';
+
+export interface RiskPresentation {
+  label: string;
+  tone: RiskTone;
+}
+
+export function getRiskPresentation(level: RiskLevel, ui: PetToxicityUI): RiskPresentation {
+  const labels: Record<RiskLevel, string> = {
+    critical: ui.riskCritical,
+    high: ui.riskHigh,
+    caution: ui.riskCaution,
+    unknown: ui.riskUnknown,
+  };
+  return { label: labels[level], tone: level };
+}
+
+export function getResultTitle(evaluation: FoodEvaluation | null, ui: PetToxicityUI): string {
+  return evaluation ? evaluation.food.name : ui.resultEmpty;
+}

package/src/tool/petToxicity/i18n/de.ts

@@ -0,0 +1,181 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { PetToxicityLocaleContent, PetToxicityUI } from '../entry';
+
+const slug = 'gefahrliche-lebensmittel-hunde-katzen-prufer';
+const title = 'Prüfer für gefährliche Lebensmittel bei Hunden und Katzen';
+const description = 'Prüfen Sie häufige Futtermittelbelastungen bei Hunden und Katzen, verstehen Sie Warnzeichen und wissen Sie, wann ein Tierarzt zu kontaktieren ist.';
+
+const ui: PetToxicityUI = {
+  "journeyHint": "Wählen Sie das Tier, öffnen Sie den Lebensmittelatlas und lesen Sie die artspezifische Warnung vor der weiteren Entscheidung.",
+  "speciesLabel": "Tierart",
+  "speciesDog": "Hund",
+  "speciesCat": "Katze",
+  "speciesDogMeta": "Hundeprofil",
+  "speciesCatMeta": "Katzenprofil",
+  "foodLabel": "Lebensmittel oder Zutat",
+  "foodPlaceholder": "Wählen Sie ein Lebensmittel",
+  "foodMenuHint": "Die Liste ändert sich mit der Tierart, da das Risiko artspezifisch ist.",
+  "resultEyebrow": "Der Lebensmittelatlas zeigt",
+  "resultEmpty": "Wählen Sie ein Lebensmittel, um die Sicherheitskarte zu öffnen.",
+  "sceneLabel": "Expositionskarte",
+  "sceneReady": "Wählen Sie ein Lebensmittel",
+  "sceneSelected": "Artspezifische Karte geöffnet",
+  "riskCritical": "Dringendes Bedenken",
+  "riskHigh": "Hohes Bedenken",
+  "riskCaution": "Vorsicht",
+  "riskUnknown": "Nicht genügend Daten",
+  "riskLabel": "Risikostufe",
+  "whyLabel": "Warum es wichtig ist",
+  "signsLabel": "Zu beobachtende Zeichen",
+  "actionLabel": "Was zu tun ist",
+  "callVetLabel": "Der sicherste nächste Schritt ist professioneller Rat.",
+  "callVetText": "Ein Rechner kann keine toxische Dosis schätzen, eine Exposition bestätigen oder eine Untersuchung ersetzen.",
+  "sourceLabel": "Verwendete Nachweise",
+  "sourceText": "Die Lebensmittelprofile basieren auf Richtlinien der Giftnotrufzentralen und der Tiertoxikologie von ASPCA, FDA und MSD Veterinary Manual.",
+  "emergencyTitle": "Wenn Ihr Haustier etwas Bedenkliches gefressen hat",
+  "emergencyText": "Rufen Sie sofort Ihren Tierarzt, eine Notfallklinik oder den Giftnotruf an. Halten Sie Verpackung, Zutatenliste, geschätzte Menge und Zeitpunkt bereit. Leiten Sie kein Erbrechen ein.",
+  "openMenu": "Optionen öffnen",
+  "closeMenu": "Optionen schließen"
+};
+
+const faq: PetToxicityLocaleContent['faq'] = [
+  {
+    "question": "Kann dieser Prüfer mir sagen, ob mein Haustier sicher ist?",
+    "answer": "Nein. Es ist ein pädagogischer Leitfaden für häufige Lebensmittelgefahren, keine Diagnose oder Dosisberechnung. Das Risiko hängt von Tierart, Produkt, Menge, Körpergewicht und Zeit seit der Aufnahme ab. Kontaktieren Sie bei Verdacht stets einen Tierarzt."
+  },
+  {
+    "question": "Welche Lebensmittel sind für Hunde besonders gefährlich?",
+    "answer": "Zu den schwerwiegenden Gefahren gehören Xylit, Schokolade und Koffein, Weintrauben und Rosinen, Zwiebeln und Knoblauch, Alkohol, Makadamianüsse und roher Hefeteig. Ein Produktetikett hilft dem Tierarzt bei der Beurteilung."
+  },
+  {
+    "question": "Sind Zwiebeln und Knoblauch für Katzen gefährlich?",
+    "answer": "Ja. Katzen reagieren besonders empfindlich auf Schäden an den roten Blutkörperchen durch Allium-Pflanzen wie Zwiebeln, Knoblauch und Schnittlauch. Rohe, gekochte, getrocknete und pulverisierte Formen sind relevant."
+  },
+  {
+    "question": "Warum zeigt Xylit für Katzen und Hunde unterschiedliche Warnungen?",
+    "answer": "Xylit führt bei Hunden zu einem raschen, lebensbedrohlichen Abfall des Blutzuckers. Bei Katzen ist diese Gefahr in Leitlinien weniger klar belegt, was jedoch kein Sicherheitsversprechen ist."
+  },
+  {
+    "question": "Was soll ich tun, wenn das gefressene Lebensmittel nicht gelistet ist?",
+    "answer": "Ein fehlender Eintrag ist kein Beweis für Sicherheit. Sichern Sie die Verpackung, notieren Sie Menge sowie Zeitpunkt und kontaktieren Sie umgehend einen Tierarzt oder Giftnotruf."
+  }
+];
+
+const howTo: PetToxicityLocaleContent['howTo'] = [
+  {
+    "name": "Tierart auswählen",
+    "text": "Wählen Sie Hund oder Katze, damit der Lebensmittelatlas die relevanten artspezifischen Nachweise anzeigt."
+  },
+  {
+    "name": "Lebensmittel auswählen",
+    "text": "Öffnen Sie das Menü und wählen Sie die passende Zutat. Beachten Sie konzentrierte oder getrocknete Produkte."
+  },
+  {
+    "name": "Sicherheitskarte lesen",
+    "text": "Überprüfen Sie, warum das Lebensmittel wichtig ist, welche Anzeichen auftreten können und welcher Schritt empfohlen wird."
+  },
+  {
+    "name": "Bei Bedarf Fachpersonal kontaktieren",
+    "text": "Rufen Sie bei einer Exposition den Tierarzt an und halten Sie Angaben zu Produkt, Menge und Tier bereit."
+  }
+];
+
+const seo: PetToxicityLocaleContent['seo'] = [
+  {
+    type: 'summary',
+    title: "Ein schneller Lebensmittelsicherheitscheck für Hunde und Katzen",
+    items: [
+      "Wählen Sie zuerst die Tierart, da dieselbe Zutat bei Hunden und Katzen unterschiedliche Bedenken auslöst.",
+      "Nutzen Sie die Lebensmittelkarten, um Gefahr, Warnzeichen und Dringlichkeit zu verstehen.",
+      "Behandeln Sie eine Xylit-Aufnahme bei Hunden als dringenden Notfall.",
+      "Verständigen Sie bei einer echten Exposition sofort den Tierarzt."
+],
+  },
+  {
+    type: 'title',
+    text: "Wie Sie den Prüfer für gefährliche Lebensmittel verantwortungsvoll nutzen",
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: "Dieser Prüfer für gefährliche Lebensmittel wurde für die entscheidende erste Minute entwickelt, nachdem ein Hund oder eine Katze etwas Unerlaubtes gefressen hat. Wählen Sie das Tier, öffnen Sie das passende Profil und nutzen Sie die Karte zur Vorbereitung des Telefonats mit der Tierarztpraxis. Die Struktur trennt den Grund der Gefahr von beobachtbaren Symptomen und empfohlenen Handlungen. Das erleichtert die Übersicht in einer anstrengenden Situation und spart wertvolle Minuten vor der Abfahrt in die Praxis.",
+  },
+  {
+    type: 'paragraph',
+    html: "Die Wahl der Tierart ist essenziell. Hunde und Katzen verstoffwechseln Substanzen unterschiedlich. Xylit verursacht bei Hunden einen schnellen Abfall des Blutzuckers, während bei Katzen Zwiebeln und Knoblauch durch eine höhere Empfindlichkeit der roten Blutkörperchen auffallen. Eine genaue Einordnung hilft dabei, Fehlinformationen in Foren vorzubeugen und die richtigen Maßnahmen zu ergreifen.",
+  },
+  {
+    type: 'title',
+    text: "Häufige Gefahren und wichtige Details",
+    level: 2,
+  },
+  {
+    type: 'table',
+    headers: ["Lebensmittel oder Zutat","Hauptbedenken","Wichtiger Kontext"],
+    rows: [["Schokolade und Koffein","Herz- und Nervensystemwirkungen","Kakaogehalt, Produktart, Menge und Körpergewicht sind entscheidend. Die Dosis bestimmt die Schwere der Vergiftung."],["Xylit","Schneller Blutzuckerabfall bei Hunden","Zuckerfreie Kaugummis, Süßwaren und Gebäck prüfen. Bereits geringe Mengen können lebensbedrohlich sein."],["Weintrauben und Rosinen","Mögliche Nierenschädigung bei Hunden","Auch kleine Mengen nicht als harmlos einstufen. Das Nierenversagen kann verzögert eintreten."],["Zwiebel und Knoblauch","Schädigung roter Blutkörperchen","Gekochte, getrocknete und pulverisierte Formen beachten. Die Anämie entwickelt sich oft erst nach Tagen."],["Roher Hefeteig","Magenausdehnung und Alkoholbildung","Aufgehender Teig erzeugt Druck und Gärungsprodukte. Es droht eine gefährliche Magendrehung."]],
+  },
+  {
+    type: 'paragraph',
+    html: "Eine Exposition kann auch aus mechanischen oder physikalischen Gründen gefährlich sein. Hefeteig geht im Magen auf, fettige Speisen können eine Bauchspeicheldrüsenentzündung begünstigen und Knochen bergen Erstickungs- sowie Verletzungsgefahren. Eine sorgfältige Beobachtung ist unerlässlich.",
+  },
+  {
+    type: 'title',
+    text: "Maßnahmen nach einer möglichen Exposition",
+    level: 2,
+  },
+  {
+    type: 'list',
+    items: [
+      "Reste entfernen und Verpackung sichern.",
+      "Tierart, Gewicht, Produkt, Menge und Zeitpunkt notieren.",
+      "Tierarzt oder Giftnotruf anrufen.",
+      "Kein Erbrechen ohne tierärztliche Anweisung einleiten.",
+      "Bei Kollaps, Atemnot oder Krämpfen sofort die Notfallklinik aufsuchen."
+],
+  },
+  {
+    type: 'tip',
+    title: "Das Wohl des Tieres steht an erster Stelle",
+    html: "Symptome können verzögert auftreten. Suchen Sie bei Vergiftungsverdacht stets professionelle Hilfe auf.",
+  },
+];
+
+const schemas: PetToxicityLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'HealthApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  } as WithContext<SoftwareApplication>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+  } as WithContext<HowTo>,
+];
+
+export const content: PetToxicityLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};

package/src/tool/petToxicity/i18n/en.ts

@@ -0,0 +1,175 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { PetToxicityLocaleContent, PetToxicityUI } from '../entry';
+
+const slug = 'pet-food-toxicity-checker';
+const title = 'Pet Food Toxicity Checker';
+const description = 'Check common food exposures for dogs and cats, understand the main warning signs, and know when to contact a veterinarian or animal poison service.';
+
+const ui: PetToxicityUI = {
+  journeyHint: 'Choose the animal, open the food atlas, and read the species-specific warning before deciding what to do next.',
+  speciesLabel: 'Animal',
+  speciesDog: 'Dog',
+  speciesCat: 'Cat',
+  speciesDogMeta: 'Dog profile',
+  speciesCatMeta: 'Cat profile',
+  foodLabel: 'Food or ingredient',
+  foodPlaceholder: 'Choose a food',
+  foodMenuHint: 'The list changes with the animal because risk is species-specific.',
+  resultEyebrow: 'The food atlas says',
+  resultEmpty: 'Choose a food to open its safety card.',
+  sceneLabel: 'Exposure map',
+  sceneReady: 'Choose a food',
+  sceneSelected: 'species-specific card open',
+  riskCritical: 'Urgent concern',
+  riskHigh: 'High concern',
+  riskCaution: 'Caution',
+  riskUnknown: 'Not enough data',
+  riskLabel: 'Risk level',
+  whyLabel: 'Why it matters',
+  signsLabel: 'Signs to watch',
+  actionLabel: 'What to do',
+  callVetLabel: 'The safest next step is professional advice.',
+  callVetText: 'A calculator cannot estimate a toxic dose, confirm an exposure, or replace an examination.',
+  sourceLabel: 'Evidence used',
+  sourceText: 'The food profiles are based on poison control and veterinary toxicology guidance from the ASPCA, FDA, and Merck Veterinary Manual. The guide is educational and does not calculate treatments or safe doses.',
+  emergencyTitle: 'If your pet has eaten something concerning',
+  emergencyText: 'Call your veterinarian, an emergency animal clinic, or an animal poison service now. Keep the package, ingredient list, estimated amount, and time of exposure. Do not induce vomiting or give a home remedy unless a veterinary professional tells you to.',
+  openMenu: 'Open options',
+  closeMenu: 'Close options',
+};
+
+const faq: PetToxicityLocaleContent['faq'] = [
+  {
+    question: 'Can this pet food toxicity checker tell me whether my pet is safe?',
+    answer: 'No. It is an educational guide to common food hazards, not a diagnosis or dose calculator. The risk depends on the species, product, amount, body size, health history, and time since exposure. If your pet has eaten a concerning food, contact a veterinarian or animal poison service even when the animal looks normal.',
+  },
+  {
+    question: 'What foods are especially dangerous for dogs?',
+    answer: 'Common serious concerns include xylitol, chocolate and caffeine, grapes and raisins, onions and garlic, alcohol, macadamia nuts, and raw yeast dough. The list is not complete. A product label and an accurate estimate of the amount help a veterinary professional assess the situation.',
+  },
+  {
+    question: 'Are onions and garlic dangerous for cats?',
+    answer: 'Yes. Veterinary toxicology guidance identifies cats as especially susceptible to red blood cell damage from allium plants such as onions, garlic, chives, and leeks. Raw, cooked, dried, powdered, and concentrated forms can matter. Delayed signs are possible, so contact a veterinarian after a known exposure instead of waiting for weakness or pale gums.',
+  },
+  {
+    question: 'Why does xylitol show a different warning for cats and dogs?',
+    answer: 'Xylitol is associated with a rapid and potentially life-threatening fall in blood sugar in dogs. FDA guidance describes a much clearer danger for dogs than for cats, but that difference is not a promise that every product is safe for a cat. Check the ingredient list and ask a veterinarian about any exposure.',
+  },
+  {
+    question: 'What should I do if my pet ate a food that is not listed?',
+    answer: 'Do not treat an absent entry as proof of safety. Save the packaging, identify the ingredients, note the amount and time, and contact a veterinarian or animal poison service. The guide intentionally keeps its profiles narrow where species-specific evidence is important.',
+  },
+];
+
+const howTo: PetToxicityLocaleContent['howTo'] = [
+  { name: 'Choose the animal', text: 'Select Dog or Cat so the food atlas shows the relevant species-specific evidence and warning.' },
+  { name: 'Choose the food', text: 'Open the food or ingredient menu and choose the closest match. Read the detail line because concentrated, cooked, powdered, and mixed products can change the context.' },
+  { name: 'Read the safety card', text: 'Review why the food matters, which general signs may appear, and the recommended next step. A caution label is not a safe-dose calculation.' },
+  { name: 'Contact a professional when needed', text: 'If exposure happened, contact a veterinarian, emergency animal clinic, or animal poison service with the product, amount, time, and pet details. Do not use a home remedy unless instructed.' },
+];
+
+const seo: PetToxicityLocaleContent['seo'] = [
+  {
+    type: 'summary',
+    title: 'A quick food safety check for dogs and cats',
+    items: [
+      'Choose the species first because the same ingredient can create different concerns for dogs and cats.',
+      'Use the food cards to understand the hazard, common warning signs, and the appropriate urgency.',
+      'Treat xylitol exposure in dogs as an urgent concern and do not wait for symptoms.',
+      'Contact a veterinarian or animal poison service for a real exposure. The checker does not calculate doses or treatments.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'How to use a pet food toxicity checker responsibly',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'This pet food toxicity checker is built for the anxious first minute after a dog or cat finds something it should not eat. Choose the animal, open the closest food profile, and use the card to organize the next conversation with a veterinary professional. The result separates the reason a food matters from the signs an owner might notice and the action that makes sense. That structure is more useful than a single green or red label because food exposures are not determined by the name of an ingredient alone.',
+  },
+  {
+    type: 'paragraph',
+    html: 'The species selector is essential. Dogs and cats do not process every substance in the same way, and a difference in evidence must not be mistaken for a guarantee of safety. Xylitol is a clear example: it can cause a rapid and dangerous blood sugar problem in dogs, while available public guidance describes a less established risk for cats. Onions and garlic show the opposite kind of nuance because cats are especially susceptible to red blood cell damage. The food list therefore changes with the animal rather than pretending that one universal table is enough.',
+  },
+  {
+    type: 'title',
+    text: 'Common food hazards and the details that change the answer',
+    level: 2,
+  },
+  {
+    type: 'table',
+    headers: ['Food or ingredient', 'Main concern', 'Important context'],
+    rows: [
+      ['Chocolate and caffeine', 'Heart and nervous system effects', 'Cocoa concentration, product type, amount, and body size matter.'],
+      ['Xylitol', 'Rapid low blood sugar in dogs', 'Check sugar-free products, gum, sweets, baked goods, and some nut butters.'],
+      ['Grapes and raisins', 'Possible kidney injury in dogs', 'Do not assume a small amount is harmless because sensitivity varies.'],
+      ['Onion and garlic', 'Red blood cell damage and anemia', 'Raw, cooked, dried, powdered, and concentrated forms can matter.'],
+      ['Raw yeast dough', 'Expansion and alcohol production', 'A rising dough can create both pressure and fermentation risk.'],
+    ],
+  },
+  {
+    type: 'paragraph',
+    html: 'A food exposure can also be dangerous for a reason that is not classic poisoning. Raw dough may expand and ferment. Fatty foods can trigger digestive upset or pancreatitis risk in some animals. Bones, pits, and corn cobs can obstruct the digestive tract. If the item is not in this checker, that is a signal to ask a professional, not permission to wait. Keep the original packaging because brand recipes, sweetener names, cocoa concentration, and serving size can change the assessment.',
+  },
+  {
+    type: 'title',
+    text: 'What to do after a possible exposure',
+    level: 2,
+  },
+  {
+    type: 'list',
+    items: [
+      'Move the remaining food away and keep the package or ingredient list.',
+      'Write down the pet species, approximate weight, food, amount, and time of exposure.',
+      'Call a veterinarian, emergency animal clinic, or animal poison service for case-specific advice.',
+      'Do not induce vomiting, give milk, give charcoal, or use another home remedy unless a professional directs you.',
+      'Seek urgent help for collapse, seizures, breathing trouble, repeated vomiting, pale gums, severe weakness, or a swollen painful abdomen.',
+    ],
+  },
+  {
+    type: 'tip',
+    title: 'The animal comes before the calendar',
+    html: 'Symptoms can be delayed, absent at first, or caused by an ingredient that the checker does not cover. If something happened in real life, professional advice is the result you need. This tool helps you prepare useful information for that call; it does not replace the call.',
+  },
+];
+
+const schemas: PetToxicityLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'HealthApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  } as WithContext<SoftwareApplication>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })),
+  } as WithContext<HowTo>,
+];
+
+export const content: PetToxicityLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};