@jjlmoya/utils-pets 1.20.0 → 1.22.0

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

@@ -0,0 +1,96 @@
+import type { CarrierResult, PetSpecies, UnitSystem } from './logic';
+import { convertLength, convertWeight, formatInputValue } from './logic';
+import { evaluateCarrier } from './evaluator';
+import type { PetCarrierCrateSizePlannerUI } from './ui';
+
+function escapeText(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[character] || character));
+}
+
+function formatMeasure(valueCm: number, unit: UnitSystem): string {
+  const value = convertLength(valueCm, 'metric', unit);
+  return `${formatInputValue(Number(value.toFixed(1)))} ${unit === 'metric' ? 'cm' : 'in'}`;
+}
+
+function formatWeight(valueKg: number, unit: UnitSystem): string {
+  const value = convertWeight(valueKg, 'metric', unit);
+  return `${formatInputValue(Number(value.toFixed(1)))} ${unit === 'metric' ? 'kg' : 'lb'}`;
+}
+
+interface DimensionArrow {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  label: string;
+  className: string;
+}
+
+interface PetPlacement {
+  species: PetSpecies;
+  boxX: number;
+  boxY: number;
+  boxWidth: number;
+  boxHeight: number;
+}
+
+function dimensionArrow({ x1, y1, x2, y2, label, className }: DimensionArrow): string {
+  return `<line class="measure-line ${className}" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" /><text class="measure-label ${className}" x="${(x1 + x2) / 2}" y="${(y1 + y2) / 2 - 5}">${escapeText(label)}</text>`;
+}
+
+function petMarkup({ species, boxX, boxY, boxWidth, boxHeight }: PetPlacement): string {
+  const size = Math.min(72, boxWidth - 32, boxHeight - 18);
+  const offsetX = boxX + (boxWidth - size) / 2;
+  const offsetY = boxY + (boxHeight - size) / 2;
+  const figure = species === 'dog'
+    ? 'm19 3l-4 4l3 3l1-1l1 1l2-2l-3-3zM3 7L2 8l3 3v3l-1 1v6h2v-3l2-3h7v6h2V11l-3-3l-1 1H5z'
+    : 'm12 8l-1.33.09C9.81 7.07 7.4 4.5 5 4.5c0 0-1.97 2.96-.04 6.91c-.55.83-.89 1.26-.96 2.25l-1.93.29l.21.98l1.76-.26l.14.71l-1.57.94l.47.89l1.45-.89C5.68 18.76 8.59 20 12 20s6.32-1.24 7.47-3.68l1.45.89l.47-.89l-1.57-.94l.14-.71l1.76.26l.21-.98l-1.93-.29c-.07-.99-.41-1.42-.96-2.25C20.97 7.46 19 4.5 19 4.5c-2.4 0-4.81 2.57-5.67 3.59zm-3 3a1 1 0 0 1 1 1a1 1 0 0 1-1 1a1 1 0 0 1-1-1a1 1 0 0 1 1-1m6 0a1 1 0 0 1 1 1a1 1 0 0 1-1 1a1 1 0 0 1-1-1a1 1 0 0 1 1-1m-4 3h2l-.7 1.39c.2.64.76 1.11 1.45 1.11a1.5 1.5 0 0 0 1.5-1.5h.5a2 2 0 0 1-2 2c-.75 0-1.4-.41-1.75-1c-.35.59-1 1-1.75 1a2 2 0 0 1-2-2h.5a1.5 1.5 0 0 0 1.5 1.5c.69 0 1.25-.47 1.45-1.11z';
+  return `<svg class="pet-icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false" x="${offsetX}" y="${offsetY}" width="${size}" height="${size}"><path d="${figure}" /></svg>`;
+}
+
+function sceneMarkup(result: CarrierResult, ui: PetCarrierCrateSizePlannerUI): string {
+  const { dimensions } = result;
+  const width = Math.min(300, Math.max(220, dimensions.lengthCm * 2.3));
+  const height = Math.min(150, Math.max(90, dimensions.heightCm * 1.5));
+  const boxX = 54;
+  const boxY = 50;
+  const boxRight = boxX + width;
+  const boxBottom = boxY + height;
+  const unit = result.input.unit;
+  return `<svg viewBox="0 0 430 230" role="img" aria-label="${escapeText(ui.blueprintLabel)}" class="carrier-blueprint">
+    <defs><marker id="measure-start" markerWidth="6" markerHeight="6" refX="3" refY="3" orient="auto"><path d="M6 0L0 3L6 6Z" fill="currentColor" /></marker><marker id="measure-end" markerWidth="6" markerHeight="6" refX="3" refY="3" orient="auto"><path d="M0 0L6 3L0 6Z" fill="currentColor" /></marker></defs>
+    <rect class="blueprint-paper" x="12" y="12" width="406" height="206" rx="18" />
+    <path class="blueprint-grid" d="M30 42H400M30 76H400M30 110H400M30 144H400M30 178H400M80 28V202M130 28V202M180 28V202M230 28V202M280 28V202M330 28V202M380 28V202" />
+    <rect class="carrier-outline" x="${boxX}" y="${boxY}" width="${width}" height="${height}" rx="16" />
+    <path class="carrier-door" d="M${boxRight - 4} ${boxY + 12}V${boxBottom - 12} M${boxRight - 18} ${boxY + 26}H${boxRight - 7} M${boxRight - 18} ${boxBottom - 26}H${boxRight - 7}" />
+    ${petMarkup({ species: result.input.species, boxX, boxY, boxWidth: width, boxHeight: height })}
+    ${dimensionArrow({ x1: boxX, y1: boxBottom + 22, x2: boxRight, y2: boxBottom + 22, label: formatMeasure(dimensions.lengthCm, unit), className: 'length' })}
+    ${dimensionArrow({ x1: boxRight + 24, y1: boxY, x2: boxRight + 24, y2: boxBottom, label: formatMeasure(dimensions.heightCm, unit), className: 'height' })}
+    <text class="blueprint-caption" x="30" y="34">${escapeText(ui.dimensionInside)}</text>
+    <text class="blueprint-badge" x="${boxX + 14}" y="${boxY + 20}">${escapeText(ui.checkMark)}</text>
+  </svg>`;
+}
+
+export function renderScene(element: HTMLElement, result: CarrierResult, ui: PetCarrierCrateSizePlannerUI): void {
+  element.innerHTML = sceneMarkup(result, ui);
+}
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  const element = root.querySelector<HTMLElement>(selector);
+  if (element) element.textContent = value;
+}
+
+export function renderEvaluation(root: HTMLElement, result: CarrierResult, ui: PetCarrierCrateSizePlannerUI): void {
+  const evaluation = evaluateCarrier(result, ui);
+  setText(root, '[data-status]', evaluation.label);
+  setText(root, '[data-status-detail]', evaluation.detail);
+  setText(root, '[data-length-result]', formatMeasure(result.dimensions.lengthCm, result.input.unit));
+  setText(root, '[data-width-result]', formatMeasure(result.dimensions.widthCm, result.input.unit));
+  setText(root, '[data-height-result]', formatMeasure(result.dimensions.heightCm, result.input.unit));
+  setText(root, '[data-weight-result]', formatWeight(result.input.weight, result.input.unit));
+  setText(root, '[data-mode-result]', result.input.mode === 'air' ? ui.modeAir : ui.modeCar);
+  const panel = root.querySelector<HTMLElement>('[data-result]');
+  if (panel) panel.hidden = false;
+  const status = root.querySelector<HTMLElement>('[data-status]');
+  if (status) status.dataset.tone = evaluation.tone;
+}

package/src/tool/petCarrierCrateSizePlanner/entry.ts

@@ -0,0 +1,27 @@
+import type { PetToolEntry, ToolLocaleContent } from '../../types';
+import type { PetCarrierCrateSizePlannerUI } from './ui';
+
+export type { PetCarrierCrateSizePlannerUI } from './ui';
+export type PetCarrierCrateSizePlannerLocaleContent = ToolLocaleContent<PetCarrierCrateSizePlannerUI>;
+
+export const petCarrierCrateSizePlanner: PetToolEntry<PetCarrierCrateSizePlannerUI> = {
+  id: 'pet-carrier-crate-size-planner',
+  icons: { bg: 'mdi:paw', fg: 'mdi:briefcase' },
+  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/petCarrierCrateSizePlanner/evaluator.ts

@@ -0,0 +1,14 @@
+import type { PetCarrierCrateSizePlannerUI } from './ui';
+import type { CarrierResult } from './logic';
+
+export interface CarrierEvaluation {
+  label: string;
+  detail: string;
+  tone: 'calm' | 'review' | 'adjusted';
+}
+
+export function evaluateCarrier(result: CarrierResult, ui: PetCarrierCrateSizePlannerUI): CarrierEvaluation {
+  if (result.dimensions.isSnubNosedAdjusted) return { label: ui.statusSnub, detail: ui.resultDetail, tone: 'adjusted' };
+  if (result.airReviewRequired) return { label: ui.statusAirReview, detail: ui.resultDetail, tone: 'review' };
+  return { label: ui.statusComfort, detail: ui.resultDetail, tone: 'calm' };
+}

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

@@ -0,0 +1,171 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { PetCarrierCrateSizePlannerLocaleContent } from '../entry';
+import type { PetCarrierCrateSizePlannerUI } from '../ui';
+
+const slug = 'haustier-transportbox-groessenplaner';
+const title = 'Haustier Transportbox Größenplaner';
+const description = 'Berechnen Sie die passenden Innenmaße einer Transportbox für Hund oder Katze anhand von sechs Körpermaßen, inklusive Flugreise-Check und Komfortliste.';
+
+const ui: PetCarrierCrateSizePlannerUI = {
+  heroEyebrow: 'Messen Sie zuerst. Kaufen Sie mit Sicherheit.',
+  journeyHint: 'Wählen Sie das Haustier und die Reiseart, geben Sie die Maße ein und nutzen Sie die Skizze als Orientierung für den Innenraum der Transportbox.',
+  unitLegend: 'Anzeigeeinheiten',
+  speciesStep: 'Beginnen Sie mit dem Tier',
+  metricUnit: 'Metrisch',
+  imperialUnit: 'Imperial',
+  speciesLegend: 'Wer reist mit?',
+  speciesDog: 'Hund',
+  speciesCat: 'Katze',
+  modeLegend: 'Wie wird gereist?',
+  modeCar: 'Auto',
+  modeAir: 'Flugzeug',
+  measurementsLegend: 'Messen Sie Ihr Haustier',
+  noseTailLabel: 'Nasenspitze bis Rutenansatz',
+  noseTailHint: 'Messen Sie ohne die Krümmung der Rute',
+  elbowHeightLabel: 'Boden bis Ellenbogen',
+  shoulderWidthLabel: 'Schulterbreite',
+  standingHeightLabel: 'Höhe im Stehen',
+  beddingLabel: 'Dicke der Decke oder Einlage',
+  weightLabel: 'Gewicht des Haustiers',
+  cmUnit: 'cm',
+  inchUnit: 'in',
+  kgUnit: 'kg',
+  lbUnit: 'lb',
+  snubNosedLabel: 'Kurzschnäuzige Rasse',
+  snubNosedHint: 'Bei Flugreisen gelten IATA Anpassungen. Sprechen Sie mit Ihrem Tierarzt und der Fluggesellschaft.',
+  presetLegend: 'Starten Sie mit einem Profil',
+  presetCat: 'Katze',
+  presetSmallDog: 'Kleiner Hund',
+  presetMediumDog: 'Mittlerer Hund',
+  presetLargeDog: 'Großer Hund',
+  resultEyebrow: 'Empfohlener Messrahmen',
+  resultTitle: 'Ausreichend Raum zum Umdrehen',
+  resultDimensionLabel: 'Mindestinnenmaße für den Start',
+  lengthLabel: 'Länge',
+  widthLabel: 'Breite',
+  heightLabel: 'Höhe',
+  petWeightLabel: 'Gewicht des Tieres',
+  journeyLabel: 'Reiseart',
+  statusComfort: 'Komfort Basisstandard',
+  statusAirReview: 'Flugreise Prüfung',
+  statusSnub: 'Anpassung für Kurzschnauzer',
+  resultDetail: 'Prüfen Sie den tatsächlichen Innenraum, die Türöffnung, Belüftung und Bestimmungen vor dem Kauf oder der Abreise.',
+  checklistTitle: 'Die vier Körperprüfungen',
+  checklistStand: 'Das Tier kann aufrecht stehen und sitzen, ohne dass das Dach den Kopf berührt.',
+  checklistTurn: 'Das Tier kann sich im Stehen mühelos umdrehen.',
+  checklistLie: 'Das Tier kann in natürlicher Haltung auf der Decke liegen.',
+  checklistAirline: 'Bei Flugreisen sind Fluggesellschaftsregeln, Belüftung, Verriegelung und Etiketten zu prüfen.',
+  invalidInput: 'Bitte geben Sie für alle Maße und das Gewicht positive Werte ein.',
+  noteTitle: 'Nutzen Sie dies als Orientierung, nicht als Flugzulassung',
+  noteText: 'Bestimmungen variieren je nach Fluggesellschaft, Fahrzeug und Tier. Ein Tierarzt sollte die gesundheitliche Eignung prüfen, besonders bei stumpfschnäuzigen Rassen.',
+  methodTitle: 'Berechnungsmethode',
+  methodText: 'Die Berechnung basiert auf den IATA Richtlinien: Länge entspricht Nase bis Rutenansatz plus halbe Ellenbogenhöhe, Breite der doppelten Schulterbreite und Höhe der Stehhöhe plus Deckenstärke.',
+  blueprintLabel: 'Maßskizze der Transportbox mit Haustier und Führungslinien für Länge und Höhe',
+  dimensionInside: 'Innenabmessungen',
+  checkMark: 'OK',
+};
+
+const faq: PetCarrierCrateSizePlannerLocaleContent['faq'] = [
+  {
+    question: 'Wie messe ich meinen Hund oder meine Katze richtig für eine Transportbox?',
+    answer: 'Messen Sie von der Nasenspitze bis zum Rutenansatz, vom Boden bis zum Ellenbogengelenk, die breiteste Stelle der Schultern sowie die Höhe vom Boden bis zur Kopfspitze oder den Ohren. Die Dicke der Liegedecke wird separat hinzugerechnet.',
+  },
+  {
+    question: 'Welche Innenmaße berechnet dieser Planer?',
+    answer: 'Er berechnet die Mindestinnenlänge aus Körperlänge plus halber Ellenbogenhöhe, die Innenbreite als doppelte Schulterbreite und die Innenhöhe aus Stehhöhe plus Deckenstärke.',
+  },
+  {
+    question: 'Garantieren die Ergebnisse die Zulassung bei einer Fluggesellschaft?',
+    answer: 'Nein. Der Reisemodus wendet IATA Referenzwerte an, jedoch legt jede Fluggesellschaft eigene Bestimmungen fest. Prüfen Sie stets die aktuellen Vorgaben der Airline vor der Buchung.',
+  },
+  {
+    question: 'Warum benötigen kurzschnäuzige Rassen bei Flugreisen mehr Platz?',
+    answer: 'IATA Richtlinien empfehlen für brachycephale Rassen größere Transportboxen, um Überhitzung und Atembeschwerden vorzubeugen. Der Rechner berechnet einen Zuschlag von 10% zur Orientierung.',
+  },
+  {
+    question: 'Sollte eine Autobox so groß wie möglich sein?',
+    answer: 'Nein. Die Box muss ausreichend Platz zum Aufstehen, Sitzen, Drehen und Liegen bieten, sollte jedoch im Fahrzeug stabil gesichert werden können und nicht zu viel Spielraum bei Bremsmanövern lassen.',
+  },
+];
+
+const howTo: PetCarrierCrateSizePlannerLocaleContent['howTo'] = [
+  { name: 'Reiseart wählen', text: 'Wählen Sie zwischen Auto und Flugzeug, um die entsprechenden Vorgaben zu berücksichtigen.' },
+  { name: 'Sechs Maße eingeben', text: 'Messen Sie Körperlänge, Ellenbogenhöhe, Schulterbreite, Stehhöhe, Deckendicke und Gewicht Ihres Tieres im ruhigen Zustand.' },
+  { name: 'Innenmaße ablesen', text: 'Nutzen Sie Länge, Breite und Höhe als Mindestmaße beim Vergleich kommerzieller Boxen.' },
+  { name: 'Bestimmungen prüfen', text: 'Prüfen Sie vor dem Kauf Verriegelung, Belüftung und Vorgaben von Fluggesellschaft oder Tierarzt.' },
+];
+
+const seo: PetCarrierCrateSizePlannerLocaleContent['seo'] = [
+  {
+    type: 'summary',
+    title: 'Wichtige Hinweise zur Auswahl der passenden Transportbox',
+    items: [
+      'Messen Sie das Tier anstelle sich nur am reinen Körpergewicht zu orientieren.',
+      'Nutzen Sie reale Innenmaße zum Vergleich kommerzieller Transportboxen.',
+      'Prüfen Sie Belüftung, Verriegelung und Stabilität des Behälters.',
+      'Flugreisen erfordern besondere Vorbereitung und eine Tierarztberatung.',
+    ],
+  },
+  { type: 'title', text: 'So planen Sie die Abmessungen der Transportbox', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Eine geeignete Transportbox muss dem Tier vier Grundbewegungen ermöglichen: aufrechtes Stehen ohne den Kopf zu krümmen, aufrechtes Sitzen, müheloses Umdrehen um die eigene Achse und natürliches Liegen in entspannter Haltung. Dieser Rechner ermittelt auf Basis der individuellen Körpermaße die passenden Innenabmessungen für Länge, Breite und Höhe. Dies ist besonders nützlich, wenn Hersteller nur Außenmaße angeben oder die Box abgerundete Ecken aufweist.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Die berechneten Werte stellen das reine nutzbare Innenmaß dar. Achten Sie beim Kauf darauf, dass dicke Liegedecken, Futternäpfe oder schräge Außenwände das tatsächliche Innenvolumen verringern können. Sollte ein Modell an einer Stelle knapp bemessen sein, empfiehlt sich die nächstgrößere Variante.',
+  },
+  { type: 'title', text: 'Bedeutung der einzelnen Körpermaße', level: 2 },
+  {
+    type: 'table',
+    headers: ['Körpermaß', 'Bedeutung für das Tier', 'Verwendung im Rechner'],
+    rows: [
+      ['Nase bis Rutenansatz', 'Bestimmt die Grundlänge ohne Rute.', 'Innenlänge'],
+      ['Boden bis Ellenbogen', 'Ermöglicht Bewegungsfreiheit beim Drehen.', 'Innenlänge'],
+      ['Schulterbreite', 'Garantiert ausreichende Breite an der stärksten Stelle.', 'Innenbreite'],
+      ['Stehhöhe', 'Schützt Kopf und Ohren vor dem Boxendach.', 'Innenhöhe'],
+      ['Deckendicke', 'Sichert die effektive Höhe nach Einlegen der Decke.', 'Innenhöhe'],
+      ['Körpergewicht', 'Dient der Überprüfung der maximalen Traglast.', 'Prüfung'],
+    ],
+  },
+  {
+    type: 'paragraph',
+    html: 'Die Berechnung basiert auf den offiziellen IATA Vorgaben für den Transport von Lebendtieren. Die Innenlänge entspricht der Körperlänge plus der halben Ellenbogenhöhe, die Breite der doppelten Schulterbreite und die Höhe der Stehhöhe zuzüglich der Deckendicke. Diese Parameter garantieren Wohlbefinden und Sicherheit während der gesamten Reise.',
+  },
+  { type: 'title', text: 'Besonderheiten bei Flugreisen und Stumpfschnauzen', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Eine reine Maßberechnung ersetzt nicht die formelle Freigabe durch die Fluggesellschaft. Faktoren wie Flugzeugtyp, Temperatur und Kennzeichnung sind entscheidend. Kurzschnäuzige Rassen benötigen wegen des Risikos von Hitzestress mehr Raum und Belüftung. Erkundigen Sie sich rechtzeitig vor Abflug bei Ihrer Airline und Ihrem Tierarzt.',
+  },
+  {
+    type: 'tip',
+    title: 'Praktische Passformprüfung im Alltag',
+    html: 'Setzen Sie das Tier in ruhiger Umgebung in die Box und beobachten Sie die Bewegungsfreiheit für einige Minuten. Das Tier sollte sich ungehindert drehen können. Wenn es eingeengt wirkt, wählen Sie eine Nummer größer.',
+  },
+];
+
+const schemas: PetCarrierCrateSizePlannerLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'LifestyleApplication',
+    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: PetCarrierCrateSizePlannerLocaleContent = { slug, title, description, ui, seo, faq, bibliography, howTo, schemas };

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

@@ -0,0 +1,171 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { PetCarrierCrateSizePlannerLocaleContent } from '../entry';
+import type { PetCarrierCrateSizePlannerUI } from '../ui';
+
+const slug = 'pet-carrier-crate-size-planner';
+const title = 'Pet Carrier Crate Size Planner';
+const description = 'Estimate practical internal carrier dimensions for a dog or cat from six measurements, with a separate air travel review and a clear comfort checklist.';
+
+const ui: PetCarrierCrateSizePlannerUI = {
+  heroEyebrow: 'Measure first. Buy with confidence.',
+  journeyHint: 'Choose the pet and journey, enter the measurements, then use the blueprint as a shopping starting point for the carrier interior.',
+  unitLegend: 'Display units',
+  speciesStep: 'Start with the animal',
+  metricUnit: 'Metric',
+  imperialUnit: 'Imperial',
+  speciesLegend: 'Who is traveling?',
+  speciesDog: 'Dog',
+  speciesCat: 'Cat',
+  modeLegend: 'Where is the journey?',
+  modeCar: 'Car',
+  modeAir: 'Air travel',
+  measurementsLegend: 'Measure the pet',
+  noseTailLabel: 'Nose to tail base',
+  noseTailHint: 'Measure without the tail curve',
+  elbowHeightLabel: 'Ground to elbow',
+  shoulderWidthLabel: 'Shoulder width',
+  standingHeightLabel: 'Standing height',
+  beddingLabel: 'Bedding thickness',
+  weightLabel: 'Pet weight',
+  cmUnit: 'cm',
+  inchUnit: 'in',
+  kgUnit: 'kg',
+  lbUnit: 'lb',
+  snubNosedLabel: 'Short nosed breed',
+  snubNosedHint: 'Air travel adds the IATA adjustment. Ask your veterinarian and airline about suitability.',
+  presetLegend: 'Start with a profile',
+  presetCat: 'Cat',
+  presetSmallDog: 'Small dog',
+  presetMediumDog: 'Medium dog',
+  presetLargeDog: 'Large dog',
+  resultEyebrow: 'Your measuring frame',
+  resultTitle: 'A room to turn in',
+  resultDimensionLabel: 'Minimum internal starting dimensions',
+  lengthLabel: 'Length',
+  widthLabel: 'Width',
+  heightLabel: 'Height',
+  petWeightLabel: 'Pet weight',
+  journeyLabel: 'Journey',
+  statusComfort: 'Comfort baseline',
+  statusAirReview: 'Air travel review',
+  statusSnub: 'Short nose adjustment',
+  resultDetail: 'Check the real carrier interior, door shape, ventilation, construction, and the operator rules before buying or traveling.',
+  checklistTitle: 'The four body checks',
+  checklistStand: 'The pet can stand and sit upright without the roof pressing down.',
+  checklistTurn: 'The pet can turn around normally while standing.',
+  checklistLie: 'The pet can lie in a natural position on the bedding.',
+  checklistAirline: 'For air travel, confirm airline limits, ventilation, secure fasteners, leak protection, and required labels.',
+  invalidInput: 'Enter positive values for every pet measurement and weight.',
+  noteTitle: 'Use this as a fit study, not a travel approval',
+  noteText: 'Carrier rules vary by airline, vehicle, route, animal, and container. A veterinarian can help assess health and travel suitability, especially for short nosed breeds or animals with breathing, anxiety, or mobility concerns.',
+  methodTitle: 'Method',
+  methodText: 'The internal baseline follows IATA guidance: length is nose to tail plus half the elbow height, width is twice the shoulder width, and height is standing height plus bedding. A 10% dimensional adjustment is applied when short nosed air travel is selected.',
+  blueprintLabel: 'A measured carrier blueprint showing the pet inside and the internal length and height guides',
+  dimensionInside: 'Interior dimensions',
+  checkMark: 'OK',
+};
+
+const faq: PetCarrierCrateSizePlannerLocaleContent['faq'] = [
+  {
+    question: 'How do I measure my dog or cat for a carrier?',
+    answer: 'Measure from the tip of the nose to the base of the tail, from the ground to the elbow, across the widest part of the shoulders, and from the ground to the top of the head or ear tip, whichever is higher. Measure the bedding thickness separately because it reduces usable height. Keep the animal standing naturally and use the largest realistic posture rather than a curled sleeping position.',
+  },
+  {
+    question: 'What carrier dimensions does this planner calculate?',
+    answer: 'It estimates internal length as nose to tail plus half the elbow height, internal width as twice the shoulder width, and internal height as standing height plus bedding. These are starting dimensions for a single animal. Door arches, sloped roofs, bowls, padding, and structural ribs can reduce usable space, so compare the result with the actual interior shape.',
+  },
+  {
+    question: 'Is the result enough to meet an airline rule?',
+    answer: 'No. The air option applies a sizing reference and keeps an airline review visible, but airlines and routes can impose additional limits. Confirm the current operator policy, accepted container construction, ventilation, labels, weight rules, documentation, and cabin or hold restrictions before travel. A carrier that fits the animal can still be rejected for another reason.',
+  },
+  {
+    question: 'Why does a short nosed breed receive a larger result for air travel?',
+    answer: 'IATA guidance indicates that short nosed breeds require a larger container. This planner applies a 10% dimensional adjustment as a visible planning allowance when that option is selected. It does not decide whether a particular animal should fly. Ask a veterinarian about respiratory risk and ask the airline whether the breed and route are accepted.',
+  },
+  {
+    question: 'Should a car carrier be as large as possible?',
+    answer: 'It should be large enough for the animal to stand, sit, turn, and lie naturally, while remaining secure in the vehicle. A very loose carrier can move during braking and may not work with the available restraint system. Check the vehicle instructions and use a carrier and restraint arrangement appropriate for the animal and journey.',
+  },
+];
+
+const howTo: PetCarrierCrateSizePlannerLocaleContent['howTo'] = [
+  { name: 'Choose the journey', text: 'Select car or air travel. Air travel keeps an additional operator review visible because the fit calculation cannot approve a route or carrier.' },
+  { name: 'Take six measurements', text: 'Measure nose to tail base, elbow height, shoulder width, standing height, bedding thickness, and body weight while the animal is calm and standing naturally.' },
+  { name: 'Read the interior blueprint', text: 'Use the length, width, and height as minimum internal starting dimensions. Check the real carrier at its narrowest and lowest usable points.' },
+  { name: 'Verify the journey', text: 'Before purchase or departure, confirm the carrier construction, ventilation, restraint, handling, documentation, and current rules with the relevant airline, vehicle guidance, and veterinarian.' },
+];
+
+const seo: PetCarrierCrateSizePlannerLocaleContent['seo'] = [
+  {
+    type: 'summary',
+    title: 'Find a carrier that gives your pet room to move',
+    items: [
+      'Measure the animal instead of choosing a carrier from weight alone.',
+      'Use the internal dimensions as a starting point for comparing real carriers.',
+      'A correct fit still needs a construction, ventilation, restraint, and operator check.',
+      'Air travel needs extra preparation, and a short nosed breed needs professional advice.',
+    ],
+  },
+  { type: 'title', text: 'How to use the pet carrier size planner', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'A carrier is a small room that must support four ordinary movements: standing, sitting upright, turning around, and lying down naturally. This planner converts the body measurements that describe those movements into a practical internal length, width, and height. It is useful when a product listing gives an outside size, when a carrier has a sloped roof, or when a cat or dog is between common commercial sizes. Enter the dimensions in the unit system you use for shopping. The unit switch preserves the same physical animal while changing the displayed values.',
+  },
+  {
+    type: 'paragraph',
+    html: 'The result is deliberately an internal starting dimension, not an external product recommendation. Compare it with the usable space inside the exact carrier. A thick bed, raised floor, door frame, taper, divider, bowl, or structural rib can take away room even when the headline dimensions look generous. Measure the lowest roof point and the narrowest section that the animal must actually use. If a carrier barely meets one dimension, choose a different shape or size so the animal is not forced to crouch, twist, or lie against hardware.',
+  },
+  { type: 'title', text: 'What each measurement means', level: 2 },
+  {
+    type: 'table',
+    headers: ['Measurement', 'Why it matters', 'Used in'],
+    rows: [
+      ['Nose to tail base', 'Sets the main front to back space without depending on a curled posture.', 'Length'],
+      ['Ground to elbow', 'Adds turning and posture room to the length estimate.', 'Length'],
+      ['Shoulder width', 'Sets side to side clearance at the widest body area.', 'Width'],
+      ['Standing height', 'Protects the head and ears from the roof.', 'Height'],
+      ['Bedding thickness', 'Keeps the usable height honest after the bed is installed.', 'Height'],
+      ['Pet weight', 'Helps you check the carrier and vehicle or operator load information.', 'Review'],
+    ],
+  },
+  {
+    type: 'paragraph',
+    html: 'The formulas follow the dimension guidance published by the International Air Transport Association for dogs and cats: internal length is A plus one half of B, internal width is C multiplied by two, and internal height is D plus bedding. In that guidance, A is nose to tail base, B is ground to elbow, C is the greater of shoulder width or the widest point, and D is standing height to the top of the head or ear tip. The planner uses the same structure for a car fit study, while making clear that a car journey has different restraint and crash safety questions.',
+  },
+  { type: 'title', text: 'Air travel needs a second review', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'A dimension calculation cannot certify a carrier for air travel. The current airline, route, aircraft, season, animal health, and container design all matter. IATA and USDA APHIS guidance describe additional concerns such as secure construction, ventilation, leak protection, handling, labels, food and water arrangements, and documentation. A soft carrier that fits under one seat may be unsuitable for another aircraft or airline. Ask the operator for its current policy before buying a carrier or arriving at the airport.',
+  },
+  {
+    type: 'tip',
+    title: 'The fit check is a real world movement test',
+    html: 'Place the animal in the carrier while calm and observe whether it can stand, sit upright, turn around, and lie naturally without its body pressing into the door, roof, bowl, or bedding. Stop and seek professional advice if breathing, anxiety, pain, weakness, or mobility is a concern. The calculator helps you compare dimensions; it cannot assess an animal or approve a journey.',
+  },
+];
+
+const schemas: PetCarrierCrateSizePlannerLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'LifestyleApplication',
+    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: PetCarrierCrateSizePlannerLocaleContent = { slug, title, description, ui, seo, faq, bibliography, howTo, schemas };