@jjlmoya/utils-motor 1.1.0

package/src/tool/brakingDistanceCalculator/controller.ts

@@ -0,0 +1,114 @@
+import { renderBrakingResult, renderControlValues } from './dom-views';
+import { evaluateBraking, evaluateSafetyDistance } from './evaluator';
+import { calculateBrakingDistance, calculateSafetyDistanceScenario, type SpeedUnit, type VehicleType } from './logic';
+import { loadBrakingState, saveBrakingState, type BrakingState } from './storage';
+import type { BrakingDistanceCalculatorUI } from './ui';
+
+function rangeValue(root: HTMLElement, id: string): number {
+  return Number(root.querySelector<HTMLInputElement>(`#${id}`)?.value ?? 0);
+}
+
+function selectedValue<T extends string>(root: HTMLElement, selector: string, fallback: T): T {
+  return (root.querySelector<HTMLElement>(`${selector}[aria-pressed="true"]`)?.dataset.value as T) ?? fallback;
+}
+
+function readState(root: HTMLElement): BrakingState {
+  return {
+    speed: rangeValue(root, 'bdc-speed'),
+    reactionTime: rangeValue(root, 'bdc-reaction-time'),
+    deceleration: rangeValue(root, 'bdc-deceleration'),
+    gradePercent: rangeValue(root, 'bdc-grade'),
+    gapSeconds: rangeValue(root, 'bdc-gap-seconds'),
+    unit: selectedValue<SpeedUnit>(root, '[data-unit-button]', 'kmh'),
+    vehicle: selectedValue<VehicleType>(root, '[data-vehicle-button]', 'car'),
+  };
+}
+
+function setPressed(buttons: NodeListOf<HTMLButtonElement>, active: HTMLButtonElement): void {
+  buttons.forEach((button) => button.setAttribute('aria-pressed', String(button === active)));
+}
+
+function applyRange(root: HTMLElement, id: string, value: number): void {
+  const input = root.querySelector<HTMLInputElement>(`#${id}`);
+  if (input && Number.isFinite(value)) input.value = String(value);
+}
+
+function applyChoice(root: HTMLElement, selector: string, value: string): void {
+  const buttons = root.querySelectorAll<HTMLButtonElement>(selector);
+  const active = Array.from(buttons).find((button) => button.dataset.value === value);
+  if (active) setPressed(buttons, active);
+}
+
+function applyState(root: HTMLElement, state: BrakingState): void {
+  applyRange(root, 'bdc-speed', state.speed);
+  applyRange(root, 'bdc-reaction-time', state.reactionTime);
+  applyRange(root, 'bdc-deceleration', state.deceleration);
+  applyRange(root, 'bdc-grade', state.gradePercent);
+  applyRange(root, 'bdc-gap-seconds', state.gapSeconds);
+  applyChoice(root, '[data-unit-button]', state.unit);
+  applyChoice(root, '[data-vehicle-button]', state.vehicle);
+}
+
+function update(root: HTMLElement, ui: BrakingDistanceCalculatorUI): void {
+  const state = readState(root);
+  const result = calculateBrakingDistance(state);
+  const scenario = calculateSafetyDistanceScenario(result, state.gapSeconds);
+  renderControlValues(root);
+  renderBrakingResult(
+    root,
+    {
+      result,
+      evaluation: evaluateBraking(result, state.vehicle),
+      scenario,
+      safetyEvaluation: evaluateSafetyDistance(scenario, result),
+    },
+    ui,
+  );
+  saveBrakingState(state);
+}
+
+function bindSimulation(root: HTMLElement): void {
+  const button = root.querySelector<HTMLButtonElement>('[data-bdc-simulate]');
+  const vehicle = root.querySelector<HTMLElement>('.bdc-vehicle');
+  button?.addEventListener('click', () => {
+    root.dataset.simulating = 'false';
+    window.requestAnimationFrame(() => {
+      root.dataset.simulating = 'true';
+    });
+  });
+  vehicle?.addEventListener('animationend', () => {
+    root.dataset.simulating = 'complete';
+  });
+}
+
+function bindChoice(root: HTMLElement, selector: string, ui: BrakingDistanceCalculatorUI): void {
+  const buttons = root.querySelectorAll<HTMLButtonElement>(selector);
+  buttons.forEach((button) => button.addEventListener('click', () => {
+    setPressed(buttons, button);
+    update(root, ui);
+  }));
+}
+
+function bindSurface(root: HTMLElement, ui: BrakingDistanceCalculatorUI): void {
+  const buttons = root.querySelectorAll<HTMLButtonElement>('[data-surface-button]');
+  buttons.forEach((button) => button.addEventListener('click', () => {
+    setPressed(buttons, button);
+    applyRange(root, 'bdc-deceleration', Number(button.dataset.deceleration));
+    update(root, ui);
+  }));
+}
+
+export function initBrakingDistanceCalculator(ui: BrakingDistanceCalculatorUI): void {
+  const root = document.querySelector<HTMLElement>('[data-braking-distance-calculator]');
+  if (!root) return;
+  const saved = loadBrakingState();
+  if (saved) applyState(root, saved);
+  root.querySelectorAll<HTMLInputElement>('input[type="range"]').forEach((input) => {
+    input.addEventListener('input', () => update(root, ui));
+  });
+  bindChoice(root, '[data-unit-button]', ui);
+  bindChoice(root, '[data-vehicle-button]', ui);
+  bindSurface(root, ui);
+  bindSimulation(root);
+  update(root, ui);
+}

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

@@ -0,0 +1,58 @@
+import type { BrakingEvaluation, SafetyDistanceEvaluation } from './evaluator';
+import type { BrakingResult, SafetyDistanceScenario } from './logic';
+import type { BrakingDistanceCalculatorUI } from './ui';
+
+interface BrakingRenderModel {
+  result: BrakingResult;
+  evaluation: BrakingEvaluation;
+  scenario: SafetyDistanceScenario;
+  safetyEvaluation: SafetyDistanceEvaluation;
+}
+
+function setText(root: HTMLElement, selector: string, value: string): void {
+  const element = root.querySelector<HTMLElement>(selector);
+  if (element) element.textContent = value;
+}
+
+function formatDistance(value: number): string {
+  return `${value.toFixed(1)} m`;
+}
+
+function renderRoad(root: HTMLElement, result: BrakingResult, scenario: SafetyDistanceScenario): void {
+  const extent = Math.max(result.totalDistance, scenario.gapDistance, 0.1) * 1.12;
+  const reactionShare = `${(result.reactionDistance / extent) * 100}%`;
+  const brakingShare = `${(result.brakingDistance / extent) * 100}%`;
+  root.style.setProperty('--bdc-reaction-share', reactionShare);
+  root.style.setProperty('--bdc-braking-share', brakingShare);
+  root.style.setProperty('--bdc-stop-share', `${(result.totalDistance / extent) * 100}%`);
+  root.style.setProperty('--bdc-gap-share', `${(scenario.gapDistance / extent) * 100}%`);
+}
+
+export function renderBrakingResult(
+  root: HTMLElement,
+  model: BrakingRenderModel,
+  ui: BrakingDistanceCalculatorUI,
+): void {
+  const { result, evaluation, scenario, safetyEvaluation } = model;
+  setText(root, '[data-bdc-reaction]', formatDistance(result.reactionDistance));
+  setText(root, '[data-bdc-braking]', formatDistance(result.brakingDistance));
+  setText(root, '[data-bdc-total]', formatDistance(result.totalDistance));
+  setText(root, '[data-bdc-time]', `${result.totalTime.toFixed(1)} s`);
+  setText(root, '[data-bdc-status]', ui[evaluation.messageKey]);
+  setText(root, '[data-bdc-vehicle-note]', ui[evaluation.vehicleNoteKey]);
+  setText(root, '[data-bdc-gap-distance]', formatDistance(scenario.gapDistance));
+  setText(root, '[data-bdc-margin]', formatDistance(Math.abs(scenario.marginDistance)));
+  setText(root, '[data-bdc-margin-label]', scenario.marginDistance >= 0 ? ui.marginLabel : ui.shortfallLabel);
+  setText(root, '[data-bdc-gap-message]', ui[safetyEvaluation.messageKey]);
+  const gapLab = root.querySelector<HTMLElement>('.bdc-gap-lab');
+  if (gapLab) gapLab.dataset.gapStatus = safetyEvaluation.status;
+  root.dataset.status = evaluation.status;
+  root.dataset.simulating = 'false';
+  renderRoad(root, result, scenario);
+}
+
+export function renderControlValues(root: HTMLElement): void {
+  root.querySelectorAll<HTMLInputElement>('input[type="range"]').forEach((input) => {
+    setText(root, `[data-output="${input.id}"]`, input.value);
+  });
+}

package/src/tool/brakingDistanceCalculator/entry.ts

@@ -0,0 +1,30 @@
+import type { MotorToolEntry, ToolLocaleContent } from '../../types';
+import type { BrakingDistanceCalculatorUI } from './ui';
+
+export type { BrakingDistanceCalculatorUI };
+export type BrakingDistanceCalculatorLocaleContent = ToolLocaleContent<BrakingDistanceCalculatorUI>;
+
+export const brakingDistanceCalculator: MotorToolEntry<BrakingDistanceCalculatorUI> = {
+  id: 'braking-distance-calculator',
+  icons: {
+    bg: 'mdi:car-brake-alert',
+    fg: 'mdi:road-variant',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/brakingDistanceCalculator/evaluator.ts

@@ -0,0 +1,45 @@
+import type { BrakingResult, SafetyDistanceScenario, VehicleType } from './logic';
+
+export type BrakingStatus = 'normal' | 'warning' | 'critical';
+
+export interface BrakingEvaluation {
+  status: BrakingStatus;
+  messageKey: 'normalMessage' | 'warningMessage' | 'criticalMessage';
+  vehicleNoteKey: 'carNote' | 'motorcycleNote';
+}
+
+export type SafetyDistanceStatus = 'enough' | 'tight' | 'insufficient';
+
+export interface SafetyDistanceEvaluation {
+  status: SafetyDistanceStatus;
+  messageKey: 'enoughGapMessage' | 'tightGapMessage' | 'insufficientGapMessage';
+}
+
+function statusFor(result: BrakingResult): BrakingStatus {
+  if (result.effectiveDeceleration <= 0.75 || result.totalDistance >= 200) return 'critical';
+  if (result.effectiveDeceleration <= 1.75 || result.totalDistance >= 100) return 'warning';
+  return 'normal';
+}
+
+export function evaluateBraking(
+  result: BrakingResult,
+  vehicle: VehicleType,
+): BrakingEvaluation {
+  const status = statusFor(result);
+  const messageKey = `${status}Message` as BrakingEvaluation['messageKey'];
+  const vehicleNoteKey = vehicle === 'motorcycle' ? 'motorcycleNote' : 'carNote';
+  return { status, messageKey, vehicleNoteKey };
+}
+
+export function evaluateSafetyDistance(
+  scenario: SafetyDistanceScenario,
+  result: BrakingResult,
+): SafetyDistanceEvaluation {
+  if (scenario.marginDistance < 0) {
+    return { status: 'insufficient', messageKey: 'insufficientGapMessage' };
+  }
+  if (scenario.marginDistance < result.totalDistance * 0.25) {
+    return { status: 'tight', messageKey: 'tightGapMessage' };
+  }
+  return { status: 'enough', messageKey: 'enoughGapMessage' };
+}

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

@@ -0,0 +1,45 @@
+import { createLocalizedContent } from './factory';
+
+export const content = createLocalizedContent({
+  locale: 'de',
+  slug: 'bremsweg-rechner',
+  title: 'Bremswegrechner für Autos und Motorräder',
+  description: 'Berechne Reaktionsweg, Bremsweg und Anhalteweg anhand von Geschwindigkeit, Reaktionszeit, Fahrbahngriff und Steigung.',
+  faqTitle: 'Häufig gestellte Fragen', bibliographyTitle: 'Quellen und Literatur',
+  ui: {
+    unitLabel: 'Einheiten', metricUnit: 'km/h', imperialUnit: 'mph', vehicleLabel: 'Fahrzeug', carLabel: 'Auto', motorcycleLabel: 'Motorrad',
+    speedLabel: 'Ausgangsgeschwindigkeit', reactionTimeLabel: 'Reaktionszeit', gradeLabel: 'Fahrbahnneigung', roadConditionLabel: 'Fahrbahngriff',
+    dryRoadLabel: 'Trocken', wetRoadLabel: 'Nass', snowRoadLabel: 'Schnee', iceRoadLabel: 'Eis', decelerationLabel: 'Angenommene Verzögerung',
+    reactionDistanceLabel: 'Reaktion', brakingDistanceLabel: 'Bremsung', totalDistanceLabel: 'Gesamter Anhalteweg', totalTimeLabel: 'Gesamte Anhaltezeit',
+    roadStartLabel: 'Gefahr erkannt', brakePointLabel: 'Bremsbeginn', stopPointLabel: 'Stillstand', safetyExperimentLabel: 'Sicherheitsabstand testen',
+    safetyExperimentHint: 'Konservatives Szenario: Der vorausfahrende Verkehr wird beim Erkennen zur festen Gefahr.', gapTimeLabel: 'Zeitlicher Abstand', availableDistanceLabel: 'Verfügbarer Weg',
+    marginLabel: 'Sicherheitsreserve', shortfallLabel: 'Fehlender Weg', simulateLabel: 'Anhalten simulieren', leadVehicleLabel: 'Vorausfahrendes Fahrzeug',
+    enoughGapMessage: 'Der berechnete Anhalteweg passt, und es bleibt etwas Reserve.', tightGapMessage: 'Der Anhalteweg passt nur knapp. Unter realen Bedingungen ist mehr Reserve nötig.',
+    insufficientGapMessage: 'Das Fahrzeug erreicht den vorausfahrenden Verkehr, bevor der berechnete Anhaltevorgang beendet ist.', advancedLabel: 'Erweiterte Bremsannahme',
+    normalMessage: 'Der berechnete Anhalteweg bleibt überschaubar, reale Bedingungen erfordern dennoch eine Sicherheitsreserve.', warningMessage: 'Der benötigte Fahrbahnabschnitt ist länger, als er vom Fahrersitz aus wirkt.',
+    criticalMessage: 'Sehr geringer Grip oder hohe Geschwindigkeit führen zu einem extremen Anhalteweg.', carNote: 'Das Verhalten eines Autos hängt von Reifen, Bremsenzustand, Beladung, ABS und Fahrbahnqualität ab.',
+    motorcycleNote: 'Beim Motorrad wirken sich außerdem Fahrtechnik, Bremsverteilung, Schräglage, Reifen und Fahrbahn aus.', estimateNotice: 'Nur eine Lernschätzung. Das Ergebnis ist weder ein garantierter Sicherheitsabstand noch ein Ersatz für Verkehrsregeln.',
+  },
+  faq: [
+    { question: 'Was unterscheidet Reaktionsweg und Bremsweg?', answer: 'Der Reaktionsweg wird zurückgelegt, bevor die Bremsung beginnt. Der Bremsweg beginnt mit der Wirkung der Bremsen und endet im Stillstand. Beide zusammen ergeben den Anhalteweg.' },
+    { question: 'Warum wächst der Anhalteweg mit der Geschwindigkeit so stark?', answer: 'Der Reaktionsweg steigt proportional zur Geschwindigkeit, der Bremsweg dagegen ungefähr mit ihrem Quadrat. Eine Verdopplung der Geschwindigkeit kann den Bremsanteil unter gleichen Bedingungen etwa vervierfachen.' },
+    { question: 'Wie beeinflusst die Fahrbahnneigung das Ergebnis?', answer: 'Eine Steigung erhöht die effektive Verzögerung, ein Gefälle verringert sie. Der Rechner berücksichtigt die Neigung als Schwerkraftkomponente nach dem Aufbau des FHWA-Modells für die Anhaltesichtweite.' },
+    { question: 'Ist das Ergebnis ein garantierter Sicherheitsabstand?', answer: 'Nein. Reifen, Bremsen, Aufmerksamkeit, Beladung, Wetter, Verschmutzung, ABS und Messfehler verändern den tatsächlichen Weg. Halte dich an die Verkehrsregeln und plane eine größere Reserve ein.' },
+  ],
+  howTo: [
+    { name: 'Einheit und Fahrzeug wählen', text: 'Wähle Kilometer oder Meilen pro Stunde und anschließend Auto oder Motorrad für den passenden Sicherheitshinweis.' },
+    { name: 'Geschwindigkeit und Reaktionszeit einstellen', text: 'Passe beide Regler an das Szenario an, das du untersuchen möchtest.' },
+    { name: 'Fahrbahn beschreiben', text: 'Wähle einen Gripwert, verfeinere bei Bedarf die Verzögerung und gib für eine Steigung einen positiven, für ein Gefälle einen negativen Wert ein.' },
+    { name: 'Anhaltevorgang ablesen', text: 'Vergleiche den blauen Reaktionsabschnitt mit dem gelben Bremsabschnitt und prüfe Gesamtweg und Gesamtzeit.' },
+    { name: 'Abstand erproben', text: 'Lege einen zeitlichen Abstand fest und starte die Simulation, um im konservativen Szenario zu sehen, ob das Fahrzeug rechtzeitig anhält.' },
+  ],
+  seo: {
+    constructionTitle: 'So setzt sich der Anhalteweg zusammen', constructionText: 'Ein vollständiger Anhaltevorgang besteht aus zwei Phasen. Während <strong>Wahrnehmung und Reaktion</strong> fährt das Fahrzeug nahezu mit der Ausgangsgeschwindigkeit weiter. Danach müssen Reifen und Fahrbahn die Bewegungsenergie abbauen. Der Rechner zeigt beide Wege getrennt, damit Reaktionszeit und Bremsleistung nicht verwechselt werden.',
+    partsValue: '2 Phasen', partsLabel: 'Reaktion plus Bremsung', speedValue: 'Tempo²', speedLabel: 'Wachstum des Bremswegs', localValue: '100 % lokal', localLabel: 'Keine Fahrtdaten werden übertragen',
+    formulaTitle: 'Die Formel hinter der Schätzung', formulaText: 'Der Reaktionsweg entspricht der Geschwindigkeit in Metern pro Sekunde multipliziert mit der Reaktionszeit. Der Bremsweg ergibt sich aus dem Quadrat der Geschwindigkeit, geteilt durch die doppelte effektive Verzögerung. Darin sind Bremsannahme und Schwerkrafteinfluss der Neigung enthalten.',
+    tableHeaders: ['Eingabe', 'Auswirkung', 'Bedeutung'], tableRows: [['Geschwindigkeit', 'Beide Phasen', 'Der Bremsweg wächst ungefähr quadratisch'], ['Reaktionszeit', 'Reaktionsphase', 'Ablenkung und Müdigkeit verlängern den Weg vor dem Bremsen'], ['Verzögerung', 'Bremsphase', 'Grip, Reifen, Bremsen und Oberfläche bestimmen die mögliche Verzögerung'], ['Neigung', 'Bremsphase', 'Die Schwerkraft unterstützt die Talfahrt und bremst bergauf']],
+    presetsTitle: 'Fahrbahnwerte sind Szenarien, keine Zertifizierung', tipTitle: 'Im Zweifel konservativ rechnen', tipText: 'Trocken, nass, Schnee und Eis sind nachvollziehbare Modellannahmen. Sie prüfen weder Reifen noch Fahrbahn. Teste bei Unsicherheit eine geringere Verzögerung und eine längere Reaktionszeit und beachte die geltenden Abstandsregeln.',
+    experimentTitle: 'Den verfügbaren Abstand ausprobieren', experimentText: 'Das Experiment rechnet den gewählten Zeitabstand bei der eingestellten Geschwindigkeit in Meter um und vergleicht ihn mit dem gesamten Anhalteweg. Der vorausfahrende Verkehr wird bewusst als feste Gefahr behandelt. Das ist eine konservative Veranschaulichung, keine Vorhersage zweier bewegter Fahrzeuge.',
+    marginTitle: 'Autos und Motorräder brauchen reale Reserven', marginText: 'Das physikalische Modell veranschaulicht beide Fahrzeugarten, bildet aber kein bestimmtes Fahrzeug ab. Bremstemperatur, Reifenmischung, Lastverlagerung, ABS-Abstimmung, Fahrtechnik, Verschmutzung und Wetter können das reale Ergebnis deutlich verändern.',
+  },
+});

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

@@ -0,0 +1,208 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import { bibliographyEntries } from '../bibliography';
+import type { BrakingDistanceCalculatorUI } from '../ui';
+
+const slug = 'braking-distance-calculator';
+const title = 'Braking Distance Calculator for Cars and Motorcycles';
+const description =
+  'Estimate reaction, braking, and total stopping distance from speed, reaction time, road grip, and gradient for cars and motorcycles.';
+
+const faqData = [
+  {
+    question: 'What is the difference between reaction distance and braking distance?',
+    answer:
+      'Reaction distance is the ground covered before braking begins. Braking distance starts when the brakes take effect and ends when the vehicle stops. Total stopping distance is the sum of both parts.',
+  },
+  {
+    question: 'Why does stopping distance grow so quickly with speed?',
+    answer:
+      'Reaction distance grows in direct proportion to speed, while braking distance grows approximately with speed squared. Doubling speed can therefore make the braking portion about four times longer under the same conditions.',
+  },
+  {
+    question: 'How does a road gradient change the estimate?',
+    answer:
+      'An uphill gradient adds to effective deceleration and a downhill gradient reduces it. The calculator applies the grade as a gravitational component, following the structure of the FHWA stopping sight distance model.',
+  },
+  {
+    question: 'Can this result be used as a guaranteed safe following distance?',
+    answer:
+      'No. Tires, brakes, rider or driver attention, load, weather, surface contamination, ABS behavior, and measurement error can all change the real distance. Use official road rules and leave a larger safety margin.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Choose the speed unit and vehicle',
+    text: 'Select kilometers per hour or miles per hour, then choose car or motorcycle for the relevant safety reminder.',
+  },
+  {
+    name: 'Set speed and reaction time',
+    text: 'Move the speed and perception reaction time controls to match the scenario you want to explore.',
+  },
+  {
+    name: 'Describe the road',
+    text: 'Choose a grip preset, refine the assumed deceleration if needed, and set a positive uphill or negative downhill gradient.',
+  },
+  {
+    name: 'Read the stopping sequence',
+    text: 'Compare the blue reaction segment with the amber braking segment, then review total distance and total time.',
+  },
+  {
+    name: 'Experiment with the gap',
+    text: 'Set a following time gap and run the stop simulation to see whether the modeled vehicle stops before the vehicle ahead in this conservative fixed-hazard comparison.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, index) => ({
+    '@type': 'HowToStep',
+    position: index + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilitiesApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<BrakingDistanceCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui: {
+    unitLabel: 'Units',
+    metricUnit: 'km/h',
+    imperialUnit: 'mph',
+    vehicleLabel: 'Vehicle',
+    carLabel: 'Car',
+    motorcycleLabel: 'Motorcycle',
+    speedLabel: 'Initial speed',
+    reactionTimeLabel: 'Reaction time',
+    gradeLabel: 'Road gradient',
+    roadConditionLabel: 'Road grip preset',
+    dryRoadLabel: 'Dry',
+    wetRoadLabel: 'Wet',
+    snowRoadLabel: 'Snow',
+    iceRoadLabel: 'Ice',
+    decelerationLabel: 'Assumed deceleration',
+    reactionDistanceLabel: 'Reaction',
+    brakingDistanceLabel: 'Braking',
+    totalDistanceLabel: 'Total stopping distance',
+    totalTimeLabel: 'Total stopping time',
+    roadStartLabel: 'Hazard seen',
+    brakePointLabel: 'Brakes applied',
+    stopPointLabel: 'Full stop',
+    safetyExperimentLabel: 'Safety-distance experiment',
+    safetyExperimentHint: 'Conservative scenario: traffic ahead becomes a fixed hazard the moment you notice it.',
+    gapTimeLabel: 'Following time gap',
+    availableDistanceLabel: 'Space ahead',
+    marginLabel: 'Safety buffer',
+    shortfallLabel: 'Distance short',
+    simulateLabel: 'Run stop simulation',
+    leadVehicleLabel: 'Traffic ahead',
+    enoughGapMessage: 'The modeled stop fits, with some space left over.',
+    tightGapMessage: 'The modeled stop only just fits. Real conditions need more margin.',
+    insufficientGapMessage: 'The vehicle reaches the traffic ahead before the modeled stop is complete.',
+    advancedLabel: 'Advanced braking assumption',
+    normalMessage: 'The modeled stop remains compact, but real conditions still require a safety margin.',
+    warningMessage: 'The road consumed is longer than it feels from the driver seat.',
+    criticalMessage: 'Very low grip or high speed creates an extreme stopping distance.',
+    carNote: 'Car behavior varies with tires, brake condition, load, ABS, and surface quality.',
+    motorcycleNote: 'Motorcycle stopping also depends on rider technique, brake balance, lean, tires, and surface quality.',
+    estimateNotice: 'Educational estimate only. Never use this result as a guaranteed safe distance or a substitute for traffic rules.',
+  },
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography: bibliographyEntries,
+  seo: [
+    {
+      type: 'title',
+      text: 'How Total Stopping Distance Is Built',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'A complete stop has two distinct phases. During <strong>perception and reaction</strong>, the vehicle continues at nearly its initial speed. After the brakes act, kinetic energy must be removed through tire and road forces. This calculator shows both distances separately so the hidden reaction phase cannot be mistaken for braking performance.',
+    },
+    {
+      type: 'stats',
+      columns: 3,
+      items: [
+        { value: '2 parts', label: 'Reaction plus braking' },
+        { value: 'Speed squared', label: 'Braking growth' },
+        { value: '100% local', label: 'No trip data uploaded' },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'The Formula Behind the Estimate',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Reaction distance is speed in meters per second multiplied by reaction time. Braking distance is speed squared divided by twice the effective deceleration. Effective deceleration combines the selected braking assumption with the gravitational effect of the gradient, so an uphill grade shortens the modeled brake phase while a downhill grade lengthens it.',
+    },
+    {
+      type: 'table',
+      headers: ['Input', 'What it changes', 'Why it matters'],
+      rows: [
+        ['Speed', 'Both phases', 'Braking distance grows approximately with speed squared'],
+        ['Reaction time', 'Reaction phase', 'Distraction and fatigue add distance before braking'],
+        ['Deceleration', 'Braking phase', 'Grip, tires, brakes, and surface affect achievable slowing'],
+        ['Gradient', 'Braking phase', 'Gravity assists downhill motion and resists uphill motion'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Road Presets Are Scenarios, Not Certifications',
+      level: 2,
+    },
+    {
+      type: 'tip',
+      title: 'Use the Conservative Side',
+      html: 'The dry, wet, snow, and ice controls are transparent modeling presets. They do not inspect your tires or road. If conditions are uncertain, explore a lower deceleration and a longer reaction time, then follow the official spacing rules where you drive.',
+    },
+    {
+      type: 'title',
+      text: 'Experiment With the Space Ahead',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'The safety-distance experiment converts a time gap into meters at the selected speed and compares that space with the modeled total stopping distance. The animation deliberately treats traffic ahead as a fixed hazard, making it a conservative illustration rather than a prediction of two moving vehicles.',
+    },
+    {
+      type: 'title',
+      text: 'Cars and Motorcycles Need Real World Margin',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'The same physics framework can illustrate cars and motorcycles, but it cannot reproduce a specific vehicle. Brake temperature, tire compound, load transfer, ABS calibration, rider technique, road contamination, and weather can move the real result far from a clean mathematical estimate.',
+    },
+  ],
+};

package/src/tool/brakingDistanceCalculator/i18n/es.ts

@@ -0,0 +1,46 @@
+import { createLocalizedContent } from './factory';
+
+export const content = createLocalizedContent({
+  locale: 'es',
+  slug: 'calculadora-distancia-frenado',
+  title: 'Calculadora de distancia de frenado para coches y motos',
+  description: 'Calcula la distancia de reacción, frenado y detención total según la velocidad, el tiempo de reacción, la adherencia y la pendiente.',
+  faqTitle: 'Preguntas frecuentes',
+  bibliographyTitle: 'Referencias bibliográficas',
+  ui: {
+    unitLabel: 'Unidades', metricUnit: 'km/h', imperialUnit: 'mph', vehicleLabel: 'Vehículo', carLabel: 'Coche', motorcycleLabel: 'Moto',
+    speedLabel: 'Velocidad inicial', reactionTimeLabel: 'Tiempo de reacción', gradeLabel: 'Pendiente de la vía', roadConditionLabel: 'Adherencia de la vía',
+    dryRoadLabel: 'Seca', wetRoadLabel: 'Mojada', snowRoadLabel: 'Nieve', iceRoadLabel: 'Hielo', decelerationLabel: 'Deceleración estimada',
+    reactionDistanceLabel: 'Reacción', brakingDistanceLabel: 'Frenado', totalDistanceLabel: 'Distancia total de detención', totalTimeLabel: 'Tiempo total de detención',
+    roadStartLabel: 'Peligro detectado', brakePointLabel: 'Inicio del frenado', stopPointLabel: 'Detención total', safetyExperimentLabel: 'Experimento de distancia de seguridad',
+    safetyExperimentHint: 'Escenario conservador: el tráfico precedente se convierte en un obstáculo fijo en cuanto lo detectas.', gapTimeLabel: 'Intervalo de seguimiento',
+    availableDistanceLabel: 'Espacio disponible', marginLabel: 'Margen de seguridad', shortfallLabel: 'Distancia insuficiente', simulateLabel: 'Simular la detención', leadVehicleLabel: 'Vehículo precedente',
+    enoughGapMessage: 'El vehículo se detiene dentro del espacio disponible y conserva cierto margen.', tightGapMessage: 'La detención cabe por muy poco. En condiciones reales necesitas más margen.',
+    insufficientGapMessage: 'El vehículo alcanza al tráfico precedente antes de completar la detención calculada.', advancedLabel: 'Hipótesis avanzada de frenado',
+    normalMessage: 'La detención calculada es relativamente corta, pero las condiciones reales exigen un margen de seguridad.', warningMessage: 'La distancia recorrida es mayor de lo que parece desde el puesto de conducción.',
+    criticalMessage: 'La escasa adherencia o una velocidad elevada producen una distancia de detención extrema.', carNote: 'El comportamiento del coche varía según los neumáticos, los frenos, la carga, el ABS y el estado de la vía.',
+    motorcycleNote: 'En una moto también influyen la técnica, el reparto de frenada, la inclinación, los neumáticos y el firme.', estimateNotice: 'Cálculo exclusivamente educativo. No lo utilices como distancia segura garantizada ni como sustituto de las normas de circulación.',
+  },
+  faq: [
+    { question: '¿Qué diferencia hay entre distancia de reacción y distancia de frenado?', answer: 'La distancia de reacción es la recorrida antes de empezar a frenar. La distancia de frenado comienza cuando actúan los frenos y termina al detenerse el vehículo. La distancia total de detención es la suma de ambas.' },
+    { question: '¿Por qué aumenta tan deprisa la distancia de detención con la velocidad?', answer: 'La distancia de reacción crece de forma proporcional a la velocidad, mientras que la de frenado lo hace aproximadamente con el cuadrado de la velocidad. En las mismas condiciones, duplicar la velocidad puede cuadruplicar la parte correspondiente al frenado.' },
+    { question: '¿Cómo afecta la pendiente al cálculo?', answer: 'Una pendiente ascendente aumenta la deceleración efectiva y una descendente la reduce. La calculadora incorpora la pendiente como componente gravitatoria siguiendo la estructura del modelo de distancia de visibilidad de parada de la FHWA.' },
+    { question: '¿Puedo considerar el resultado una distancia de seguridad garantizada?', answer: 'No. Los neumáticos, los frenos, la atención, la carga, el tiempo, la suciedad del firme, el ABS y los errores de medición pueden alterar la distancia real. Respeta siempre la normativa y deja un margen mayor.' },
+  ],
+  howTo: [
+    { name: 'Elige las unidades y el vehículo', text: 'Selecciona kilómetros o millas por hora y después coche o moto para mostrar la advertencia correspondiente.' },
+    { name: 'Ajusta la velocidad y la reacción', text: 'Mueve los controles de velocidad y tiempo de percepción-reacción para representar el escenario que quieres estudiar.' },
+    { name: 'Describe el estado de la vía', text: 'Elige un nivel de adherencia, ajusta la deceleración si lo necesitas e indica una pendiente positiva en subida o negativa en bajada.' },
+    { name: 'Interpreta la secuencia de detención', text: 'Compara el tramo azul de reacción con el tramo ámbar de frenado y revisa la distancia y el tiempo totales.' },
+    { name: 'Experimenta con la separación', text: 'Define un intervalo de seguimiento y ejecuta la simulación para comprobar si el vehículo se detiene antes de alcanzar al precedente en este escenario conservador.' },
+  ],
+  seo: {
+    constructionTitle: 'Cómo se compone la distancia total de detención', constructionText: 'Una detención completa tiene dos fases. Durante la <strong>percepción y reacción</strong>, el vehículo continúa casi a la velocidad inicial. Cuando actúan los frenos, la energía cinética se disipa mediante las fuerzas entre neumáticos y calzada. La calculadora separa ambas distancias para no confundir el tiempo de reacción con la capacidad de frenado.',
+    partsValue: '2 fases', partsLabel: 'Reacción más frenado', speedValue: 'Velocidad²', speedLabel: 'Crecimiento del frenado', localValue: '100 % local', localLabel: 'No se envían datos del trayecto',
+    formulaTitle: 'La fórmula utilizada', formulaText: 'La distancia de reacción es la velocidad en metros por segundo multiplicada por el tiempo de reacción. La distancia de frenado es la velocidad al cuadrado dividida entre el doble de la deceleración efectiva. Esta última combina la frenada estimada con el efecto gravitatorio de la pendiente.',
+    tableHeaders: ['Dato', 'Qué modifica', 'Por qué importa'], tableRows: [['Velocidad', 'Ambas fases', 'La distancia de frenado crece aproximadamente con su cuadrado'], ['Tiempo de reacción', 'Fase de reacción', 'La distracción y la fatiga añaden metros antes de frenar'], ['Deceleración', 'Fase de frenado', 'Depende de la adherencia, los neumáticos, los frenos y el firme'], ['Pendiente', 'Fase de frenado', 'La gravedad favorece la bajada y se opone a la subida']],
+    presetsTitle: 'Los estados de la vía son escenarios, no certificados', tipTitle: 'Adopta un criterio conservador', tipText: 'Los ajustes de seco, mojado, nieve y hielo son hipótesis transparentes. No inspeccionan tus neumáticos ni la calzada. Si hay incertidumbre, prueba una deceleración menor y un tiempo de reacción mayor, y aplica siempre las reglas oficiales.',
+    experimentTitle: 'Experimenta con el espacio disponible', experimentText: 'El experimento convierte el intervalo temporal elegido en metros a la velocidad indicada y lo compara con la distancia total de detención. La animación trata deliberadamente el tráfico precedente como un obstáculo fijo: es una representación conservadora, no una predicción de dos vehículos en movimiento.',
+    marginTitle: 'Coches y motos necesitan margen real', marginText: 'El mismo modelo físico sirve para ilustrar coches y motos, pero no reproduce un vehículo concreto. La temperatura de los frenos, el compuesto del neumático, la transferencia de carga, el ABS, la técnica de conducción, la suciedad y el tiempo pueden alejar el resultado real del cálculo ideal.',
+  },
+});