@jjlmoya/utils-motor 1.2.0 → 1.4.0

package/src/tool/tirePressureConverter/component.astro

@@ -0,0 +1,82 @@
+---
+import type { TirePressureConverterUI } from './ui';
+import { convertPressure, formatPressure, pressureNeedleAngle, type PressureConversion } from './logic';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui: rawUi } = Astro.props;
+const ui = rawUi as TirePressureConverterUI;
+const initialConversion = convertPressure(32, 'psi') as PressureConversion;
+const initialAngle = pressureNeedleAngle(initialConversion.psi);
+const initialFill = Math.min(Math.max(initialConversion.psi / 60, 0), 1) * 100;
+---
+
+<div class="tire-pressure-tool" data-tire-pressure-tool>
+  <div class="pressure-workbench">
+    <section class="pressure-input-panel" aria-labelledby="pressure-reading-label">
+      <div class="pressure-workbench-intro">
+        <p class="pressure-kicker">{ui.flowLabel}</p>
+        <p>{ui.flowHint}</p>
+      </div>
+      <div class="pressure-field">
+        <label id="pressure-reading-label" for="pressure-reading">{ui.readingLabel}</label>
+        <div class="pressure-input">
+          <input id="pressure-reading" data-pressure-input type="number" inputmode="decimal" min="0" step="any" value="32" placeholder={ui.inputPlaceholder} aria-describedby="pressure-reading-hint" />
+          <span data-selected-unit>PSI</span>
+        </div>
+        <p class="pressure-field-hint" id="pressure-reading-hint">{ui.readingHint}</p>
+      </div>
+      <fieldset class="pressure-field">
+        <legend>{ui.sourceUnitLabel}</legend>
+        <div class="pressure-unit-row">
+          <button type="button" data-unit="psi" aria-pressed="true">{ui.psiLabel}</button>
+          <button type="button" data-unit="bar" aria-pressed="false">{ui.barLabel}</button>
+          <button type="button" data-unit="kpa" aria-pressed="false">{ui.kpaLabel}</button>
+          <button type="button" data-unit="kgfcm2" aria-pressed="false">{ui.kgfcm2Label}</button>
+        </div>
+      </fieldset>
+      <fieldset class="pressure-field">
+        <legend>{ui.axleLabel}</legend>
+        <div class="pressure-axle-row">
+          <button type="button" data-axle="front" aria-pressed="false">{ui.frontAxle}</button>
+          <button type="button" data-axle="rear" aria-pressed="false">{ui.rearAxle}</button>
+          <button type="button" data-axle="all" aria-pressed="true">{ui.allAxles}</button>
+        </div>
+      </fieldset>
+      <p class="pressure-safety">{ui.safetyNote}</p>
+    </section>
+    <section class="pressure-result-panel" aria-live="polite">
+      <div class="pressure-scene" data-pressure-scene>
+        <svg class="pressure-scene-svg" viewBox="0 0 360 250" role="img" aria-label={ui.emptyMessage}>
+          <path class="pressure-scene-arc" d="M 48 188 A 132 132 0 0 1 312 188" pathLength="100" />
+          <path class="pressure-scene-arc pressure-scene-arc-active" d="M 48 188 A 132 132 0 0 1 312 188" pathLength="100" style={`stroke-dasharray:${initialFill} 100`} />
+          <circle class="pressure-scene-hub" cx="180" cy="188" r="18" />
+          <line class="pressure-scene-needle" x1="180" y1="188" x2="180" y2="66" transform={`rotate(${initialAngle} 180 188)`} />
+          <text class="pressure-scene-value" x="180" y="145" text-anchor="middle">{formatPressure(initialConversion.values.psi, 'psi')}</text>
+          <text class="pressure-scene-unit" x="180" y="164" text-anchor="middle">PSI</text>
+          <text class="pressure-scene-mark" x="42" y="214">0</text>
+          <text class="pressure-scene-mark" x="180" y="42" text-anchor="middle">30</text>
+          <text class="pressure-scene-mark" x="318" y="214" text-anchor="end">60</text>
+        </svg>
+      </div>
+      <div>
+        <p class="pressure-conversion-label">{ui.conversionLabel}</p>
+        <div class="pressure-values" data-pressure-values>
+          <div class="pressure-value"><span>{ui.psiLabel}</span><strong>{formatPressure(initialConversion.values.psi, 'psi')}</strong></div>
+          <div class="pressure-value"><span>{ui.barLabel}</span><strong>{formatPressure(initialConversion.values.bar, 'bar')}</strong></div>
+          <div class="pressure-value"><span>{ui.kpaLabel}</span><strong>{formatPressure(initialConversion.values.kpa, 'kpa')}</strong></div>
+          <div class="pressure-value"><span>{ui.kgfcm2Label}</span><strong>{formatPressure(initialConversion.values.kgfcm2, 'kgfcm2')}</strong></div>
+        </div>
+      </div>
+      <p class="pressure-status" data-pressure-status>{ui.readyMessage} {ui.allAxles}</p>
+    </section>
+  </div>
+</div>
+
+<script is:inline type="application/json" data-pressure-ui set:html={JSON.stringify(ui)}></script>
+<script>
+  import { mountTirePressureConverter } from './controller';
+  mountTirePressureConverter();
+</script>

package/src/tool/tirePressureConverter/controller.ts

@@ -0,0 +1,120 @@
+import { convertPressure, isPressureUnit, parsePressureInput, type PressureUnit } from './logic';
+import { renderConversionValues, renderPressureScene } from './dom-views';
+import { evaluatePressure } from './evaluator';
+import { loadPressureState, savePressureState, type SavedPressureState } from './storage';
+import type { TirePressureConverterUI } from './ui';
+
+type Axle = SavedPressureState['axle'];
+
+interface RuntimeElements {
+  input: HTMLInputElement;
+  scene: HTMLElement;
+  values: HTMLElement;
+  status: HTMLElement;
+  selectedUnit: HTMLElement;
+}
+
+interface UpdateContext {
+  root: HTMLElement;
+  elements: RuntimeElements;
+  ui: TirePressureConverterUI;
+}
+
+interface RuntimeContext {
+  root: HTMLElement;
+  elements: RuntimeElements;
+  ui: TirePressureConverterUI;
+}
+
+export function mountTirePressureConverter(): void {
+  const context = getContext();
+  if (!context) return;
+  const { root, elements, ui } = context;
+  const state = loadPressureState();
+  const initialUnit = getInitialUnit(state?.sourceUnit);
+  const initialAxle = getInitialAxle(state?.axle);
+  elements.input.value = state?.input ?? elements.input.value;
+  setActiveButton(root, 'unit', initialUnit);
+  setActiveButton(root, 'axle', initialAxle);
+  const update = createUpdater({ root, elements, ui });
+  bindChoiceButtons(root, 'unit', update);
+  bindChoiceButtons(root, 'axle', update);
+  elements.input.addEventListener('input', update);
+  update();
+}
+
+function getContext(): RuntimeContext | null {
+  const root = document.querySelector<HTMLElement>('[data-tire-pressure-tool]');
+  const uiScript = document.querySelector<HTMLScriptElement>('[data-pressure-ui]');
+  if (!root || !uiScript) return null;
+  const elements = getElements(root);
+  if (!elements) return null;
+  const ui = JSON.parse(uiScript.textContent ?? '{}') as TirePressureConverterUI;
+  return { root, elements, ui };
+}
+
+function getInitialUnit(value: string | undefined): PressureUnit {
+  return value && isPressureUnit(value) ? value : 'psi';
+}
+
+function getInitialAxle(value: Axle | undefined): Axle {
+  return value ?? 'all';
+}
+
+function getElements(root: HTMLElement): RuntimeElements | null {
+  const input = root.querySelector<HTMLInputElement>('[data-pressure-input]');
+  const scene = root.querySelector<HTMLElement>('[data-pressure-scene]');
+  const values = root.querySelector<HTMLElement>('[data-pressure-values]');
+  const status = root.querySelector<HTMLElement>('[data-pressure-status]');
+  const selectedUnit = root.querySelector<HTMLElement>('[data-selected-unit]');
+  if (!input || !scene || !values || !status || !selectedUnit) return null;
+  return { input, scene, values, status, selectedUnit };
+}
+
+function createUpdater({ root, elements, ui }: UpdateContext): () => void {
+  return (): void => {
+    const sourceUnit = getActiveUnit(root);
+    const axle = getActiveAxle(root);
+    const inputValue = parsePressureInput(elements.input.value);
+    const conversion = inputValue === null ? null : convertPressure(inputValue, sourceUnit);
+    const labelMap = { psi: ui.psiLabel, bar: ui.barLabel, kpa: ui.kpaLabel, kgfcm2: ui.kgfcm2Label };
+    elements.selectedUnit.textContent = labelMap[sourceUnit];
+    renderPressureScene(elements.scene, conversion, ui.emptyMessage);
+    renderConversionValues(elements.values, conversion, labelMap);
+    const evaluation = evaluatePressure(elements.input.value, sourceUnit);
+    elements.status.textContent = evaluation === 'ready' ? `${ui.readyMessage} ${axleLabel(axle, ui)}` : ui.emptyMessage;
+    elements.status.dataset.state = evaluation;
+    savePressureState({ input: elements.input.value, sourceUnit, axle });
+  };
+}
+
+function bindChoiceButtons(root: HTMLElement, group: 'unit' | 'axle', update: () => void): void {
+  root.querySelectorAll<HTMLElement>(`[data-${group}]`).forEach((button) => button.addEventListener('click', () => {
+    setActiveButton(root, group, button.dataset[group] ?? '');
+    update();
+  }));
+}
+
+function setActiveButton(root: HTMLElement, group: 'unit' | 'axle', value: string): void {
+  root.querySelectorAll<HTMLElement>(`[data-${group}]`).forEach((button) => {
+    const active = button.dataset[group] === value;
+    button.classList.toggle('is-active', active);
+    button.setAttribute('aria-pressed', String(active));
+  });
+}
+
+function getActiveUnit(root: HTMLElement): PressureUnit {
+  const value = root.querySelector<HTMLElement>('[data-unit].is-active')?.dataset.unit ?? 'psi';
+  return isPressureUnit(value) ? value : 'psi';
+}
+
+function getActiveAxle(root: HTMLElement): Axle {
+  const value = root.querySelector<HTMLElement>('[data-axle].is-active')?.dataset.axle;
+  return value === 'front' || value === 'rear' ? value : 'all';
+}
+
+function axleLabel(axle: Axle, ui: TirePressureConverterUI): string {
+  if (axle === 'front') return ui.frontAxle;
+  if (axle === 'rear') return ui.rearAxle;
+  return ui.allAxles;
+}

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

@@ -0,0 +1,31 @@
+import { formatPressure, pressureNeedleAngle, type PressureConversion, type PressureUnit } from './logic';
+
+const UNIT_ORDER: PressureUnit[] = ['psi', 'bar', 'kpa', 'kgfcm2'];
+
+export function renderPressureScene(container: HTMLElement, conversion: PressureConversion | null, label: string): void {
+  if (!conversion) {
+    container.innerHTML = `<div class="pressure-scene-empty">${label}</div>`;
+    return;
+  }
+  const angle = pressureNeedleAngle(conversion.psi);
+  const fill = Math.min(Math.max(conversion.psi / 60, 0), 1) * 100;
+  container.innerHTML = `<svg class="pressure-scene-svg" viewBox="0 0 360 250" role="img" aria-label="${label}">
+    <path class="pressure-scene-arc" d="M 48 188 A 132 132 0 0 1 312 188" pathLength="100" />
+    <path class="pressure-scene-arc pressure-scene-arc-active" d="M 48 188 A 132 132 0 0 1 312 188" pathLength="100" style="stroke-dasharray:${fill} 100" />
+    <circle class="pressure-scene-hub" cx="180" cy="188" r="18" />
+    <line class="pressure-scene-needle" x1="180" y1="188" x2="180" y2="66" transform="rotate(${angle} 180 188)" />
+    <text class="pressure-scene-value" x="180" y="145" text-anchor="middle">${formatPressure(conversion.values.psi, 'psi')}</text>
+    <text class="pressure-scene-unit" x="180" y="164" text-anchor="middle">PSI</text>
+    <text class="pressure-scene-mark" x="42" y="214">0</text>
+    <text class="pressure-scene-mark" x="180" y="42" text-anchor="middle">30</text>
+    <text class="pressure-scene-mark" x="318" y="214" text-anchor="end">60</text>
+  </svg>`;
+}
+
+export function renderConversionValues(container: HTMLElement, conversion: PressureConversion | null, labels: Record<PressureUnit, string>): void {
+  if (!conversion) {
+    container.innerHTML = '';
+    return;
+  }
+  container.innerHTML = UNIT_ORDER.map((unit) => `<div class="pressure-value"><span>${labels[unit]}</span><strong>${formatPressure(conversion.values[unit], unit)}</strong></div>`).join('');
+}

package/src/tool/tirePressureConverter/entry.ts

@@ -0,0 +1,30 @@
+import type { MotorToolEntry, ToolLocaleContent } from '../../types';
+import type { TirePressureConverterUI } from './ui';
+
+export type { TirePressureConverterUI };
+export type TirePressureConverterLocaleContent = ToolLocaleContent<TirePressureConverterUI>;
+
+export const tirePressureConverter: MotorToolEntry<TirePressureConverterUI> = {
+  id: 'tire-pressure-converter',
+  icons: {
+    bg: 'mdi:tire',
+    fg: 'mdi:gauge',
+  },
+  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/tirePressureConverter/evaluator.ts

@@ -0,0 +1,8 @@
+import { convertPressure, parsePressureInput, type PressureUnit } from './logic';
+
+export type PressureEvaluation = 'empty' | 'ready';
+
+export function evaluatePressure(input: string, unit: PressureUnit): PressureEvaluation {
+  const value = parsePressureInput(input);
+  return value !== null && convertPressure(value, unit) ? 'ready' : 'empty';
+}

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

@@ -0,0 +1,96 @@
+import type { WithContext, SoftwareApplication, FAQPage, HowTo } from 'schema-dts';
+import type { SEOSection } from '@jjlmoya/utils-shared';
+import type { TirePressureConverterLocaleContent } from '../entry';
+
+const schemas: WithContext<SoftwareApplication | FAQPage | HowTo>[] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: 'Reifendruck Umrechner',
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    description: 'Rechnen Sie den Reifendruck zwischen PSI, Bar, kPa und kgf/cm² um.',
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: [
+      {
+        '@type': 'Question',
+        name: 'Welchen Reifendruck sollte ich verwenden?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Nutzen Sie den kalten Reifendruck laut Fahrzeughandbuch oder Aufkleber an der B-Säule. Der Umrechner ändert nur die Einheiten.' },
+      },
+      {
+        '@type': 'Question',
+        name: 'Warum unterscheiden sich Reifendrücke für Vorder- und Hinterachse?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Die Gewichtsverteilung und die Achslast führen zu unterschiedlichen Vorgaben des Herstellers für vorne und hinten.' },
+      },
+    ],
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: 'Reifendruck umrechnen',
+    step: [
+      { '@type': 'HowToStep', name: 'Messwert eingeben', text: 'Geben Sie die Zahl Ihres Reifendruckprüfers ein.' },
+      { '@type': 'HowToStep', name: 'Quelleinheit wählen', text: 'Wählen Sie PSI, Bar, kPa oder kgf/cm².' },
+      { '@type': 'HowToStep', name: 'Umrechnung ablesen', text: 'Lesen Sie den entsprechenden Wert in der Ergebnisliste ab.' },
+    ],
+  },
+];
+
+const seo: SEOSection[] = [
+  { type: 'title', level: 2, text: 'Reifendruck umrechnen ohne den physikalischen Wert zu verändern' },
+  { type: 'paragraph', html: 'Verwenden Sie diesen Reifendruck-Umrechner, wenn ein Druckprüfer oder eine Tankstelle eine andere Einheit anzeigt. Geben Sie einen Wert ein und erhalten Sie PSI, Bar, kPa und kgf/cm² auf einen Blick.' },
+  { type: 'title', text: 'So nutzen Sie den Umrechner', level: 3 },
+  { type: 'list', items: ['Geben Sie den vom Druckprüfer angezeigten Wert ein.', 'Wählen Sie die gedruckte Einheit neben dem Messwert.', 'Wählen Sie Vorderachse, Hinterachse oder Alle Achsen zur Übersicht.', 'Lesen Sie den äquivalenten Wert in der Ergebniszeile ab.'] },
+  { type: 'tip', title: 'Der Umrechner bestimmt nicht Ihren Solldruck', html: 'Suchen Sie den empfohlenen Kaltdruck im Fahrzeughandbuch oder auf dem Aufkleber am Türholm. Der Wert auf der Reifenflanke ist der Höchstdruck des Reifens, keine fahrzeugspezifische Empfehlung.' },
+  { type: 'title', text: 'Druckeinheiten auf einen Blick', level: 3 },
+  { type: 'table', headers: ['Einheit', 'Bedeutung', 'Exakte Beziehung'], rows: [['PSI', 'Pfund pro Quadratzoll', '1 psi'], ['bar', 'Barometrische Druckeinheit', '1 bar = 14.5037738 psi'], ['kPa', 'Kilopascal', '1 kPa = 0.145037738 psi'], ['kgf/cm²', 'Kilogramm-Kraft pro Quadratzentimeter', '1 kgf/cm² = 14.2233433 psi']] },
+  { type: 'diagnostic', variant: 'warning', title: 'Messbedingungen prüfen', badge: 'Kaltmessung', html: 'Der Reifendruck ändert sich mit der Temperatur. Prüfen Sie den Druck gemäß Herstellerangabe immer am kalten Reifen.' },
+];
+
+export const content: TirePressureConverterLocaleContent = {
+  slug: 'reifendruck-umrechner-psi-bar-kpa-kgf-cm2',
+  title: 'Reifendruck Umrechner',
+  description: 'Rechnen Sie den Reifendruck zwischen PSI, Bar, kPa und kgf/cm² um mit Achszuordnung für Auto und Motorrad.',
+  ui: {
+    flowLabel: 'Druck-Umrechnungsbrücke',
+    flowHint: 'Geben Sie den Messwert ein, wählen Sie die Einheit und lesen Sie das Ergebnis ab.',
+    readingLabel: 'Messwert vom Prüfer',
+    readingHint: 'Geben Sie die Zahl Ihres Reifendruckprüfers ein.',
+    sourceUnitLabel: 'Mess-Einheit',
+    axleLabel: 'Achsennotiz',
+    frontAxle: 'Vorderachse',
+    rearAxle: 'Hinterachse',
+    allAxles: 'Alle Achsen',
+    conversionLabel: 'Äquivalenter Reifendruck',
+    psiLabel: 'PSI',
+    barLabel: 'bar',
+    kpaLabel: 'kPa',
+    kgfcm2Label: 'kgf/cm²',
+    readyMessage: 'Umgerechnet für',
+    emptyMessage: 'Geben Sie einen Reifendruckwert ein.',
+    safetyNote: 'Dieses Tool rechnet Einheiten um. Den empfohlenen Reifendruck finden Sie in Ihrer Betriebsanleitung.',
+    inputPlaceholder: 'z.B. 2.2',
+  },
+  seo,
+  faqTitle: 'Fragen zum Reifendruck-Umrechner',
+  faq: [
+    { question: 'Welchen Reifendruck soll ich einstellen?', answer: 'Nutzen Sie die Vorgabe für den kalten Reifen aus der Betriebsanleitung oder dem Türstempel. Dieses Tool rechnet nur die Einheit um.' },
+    { question: 'Warum haben Vorder- und Hinterachse oft unterschiedlichen Druck?', answer: 'Unterschiedliche Achslasten und die Gewichtsverteilung erfordern verschiedene Luftdrücke für vorne und hinten.' },
+    { question: 'Ist der Wert auf der Reifenflanke der empfohlene Druck?', answer: 'Nein. Der Aufdruck auf der Reifenflanke zeigt den maximal zulässigen Druck des Reifens an.' },
+  ],
+  bibliographyTitle: 'Quellen',
+  bibliography: [
+    { name: 'ADAC Reifendruck Ratgeber', url: 'https://www.adac.de' },
+    { name: 'Continental Reifendruck Tipps', url: 'https://www.continental-reifen.de' },
+  ],
+  howTo: [
+    { name: 'Messwert eingeben', text: 'Geben Sie die Zahl Ihres Reifendruckprüfers ein.' },
+    { name: 'Quelleinheit wählen', text: 'Wählen Sie PSI, Bar, kPa oder kgf/cm².' },
+    { name: 'Umrechnung ablesen', text: 'Lesen Sie den entsprechenden Wert in der Ergebnisliste ab.' },
+  ],
+  schemas,
+};

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

@@ -0,0 +1,96 @@
+import type { WithContext, SoftwareApplication, FAQPage, HowTo } from 'schema-dts';
+import type { SEOSection } from '@jjlmoya/utils-shared';
+import type { TirePressureConverterLocaleContent } from '../entry';
+
+const schemas: WithContext<SoftwareApplication | FAQPage | HowTo>[] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: 'Tire Pressure Converter',
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+    description: 'Convert tire pressure between PSI, bar, kPa and kgf/cm² without guessing a vehicle setting.',
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: [
+      {
+        '@type': 'Question',
+        name: 'Which tire pressure should I use?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Use the cold tire pressure on the vehicle information placard or in the owner manual. The converter only changes units.' },
+      },
+      {
+        '@type': 'Question',
+        name: 'Why can front and rear pressures differ?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Vehicle weight distribution, axle loads and the manufacturer setup can make the front and rear recommendations different.' },
+      },
+    ],
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: 'Convert a tire pressure reading',
+    step: [
+      { '@type': 'HowToStep', name: 'Enter the reading', text: 'Enter the number shown by your gauge.' },
+      { '@type': 'HowToStep', name: 'Choose the source unit', text: 'Select PSI, bar, kPa or kgf/cm².' },
+      { '@type': 'HowToStep', name: 'Read the conversion', text: 'Use the matching value in the result strip.' },
+    ],
+  },
+];
+
+const seo: SEOSection[] = [
+  { type: 'title', level: 2, text: 'Convert tire pressure without changing the physical reading' },
+  { type: 'paragraph', html: 'Use this tire pressure converter when a gauge, service station or vehicle placard uses a different unit. Enter one reading and get PSI, bar, kPa and kgf/cm² in one view.' },
+  { type: 'title', text: 'How to use the converter', level: 3 },
+  { type: 'list', items: ['Enter the pressure shown by the gauge.', 'Choose the unit printed beside that reading.', 'Select Front, Rear or All axles to keep your note organized.', 'Read the equivalent value in the conversion strip.'] },
+  { type: 'tip', title: 'The converter does not choose your target pressure', html: 'Find the recommended cold pressure on the vehicle information placard or in the owner manual. The number moulded on a tire sidewall is a maximum for the tire, not a vehicle-specific recommendation.' },
+  { type: 'title', text: 'Pressure units at a glance', level: 3 },
+  { type: 'table', headers: ['Unit', 'Meaning', 'Exact relationship'], rows: [['PSI', 'Pounds per square inch', '1 psi'], ['bar', 'Barometric pressure unit', '1 bar = 14.5037738 psi'], ['kPa', 'Kilopascal', '1 kPa = 0.145037738 psi'], ['kgf/cm²', 'Kilogram-force per square centimetre', '1 kgf/cm² = 14.2233433 psi']] },
+  { type: 'diagnostic', variant: 'warning', title: 'Check the condition of the reading', badge: 'Cold reading', html: 'Pressure changes with temperature. For a reliable comparison, follow the vehicle maker instructions for checking a cold tire and use a trustworthy gauge.' },
+];
+
+export const content: TirePressureConverterLocaleContent = {
+  slug: 'tire-pressure-converter-psi-bar-kpa-kgf-cm2',
+  title: 'Tire Pressure Converter',
+  description: 'Convert PSI, bar, kPa and kgf/cm² for car and motorcycle tire readings, with clear axle notes and no invented pressure recommendations.',
+  ui: {
+    flowLabel: 'Pressure bridge',
+    flowHint: 'Enter the reading you have, choose its unit, then use the equivalent value wherever you need it.',
+    readingLabel: 'Your gauge reading',
+    readingHint: 'Use the number currently shown by your gauge or placard.',
+    sourceUnitLabel: 'Reading unit',
+    axleLabel: 'Axle note',
+    frontAxle: 'Front',
+    rearAxle: 'Rear',
+    allAxles: 'All axles',
+    conversionLabel: 'Equivalent pressure',
+    psiLabel: 'PSI',
+    barLabel: 'bar',
+    kpaLabel: 'kPa',
+    kgfcm2Label: 'kgf/cm²',
+    readyMessage: 'Converted for',
+    emptyMessage: 'Enter a pressure reading to see the bridge.',
+    safetyNote: 'This tool translates units. It cannot tell you the correct pressure for a specific vehicle, load or tire.',
+    inputPlaceholder: 'e.g. 32',
+  },
+  seo,
+  faqTitle: 'Tire pressure converter questions',
+  faq: [
+    { question: 'Which tire pressure should I use?', answer: 'Use the cold tire pressure on the vehicle information placard or in the owner manual. This tool only converts the unit.' },
+    { question: 'Why can front and rear pressures differ?', answer: 'Different axle loads and the vehicle manufacturer setup can make the front and rear recommendations different.' },
+    { question: 'Is tire sidewall pressure the recommended setting?', answer: 'No. The sidewall number is a tire limit. Use the vehicle placard or owner manual for the recommended cold pressure.' },
+  ],
+  bibliographyTitle: 'Sources',
+  bibliography: [
+    { name: 'NHTSA Tire Safety Ratings and Awareness', url: 'https://www.nhtsa.gov/vehicle-safety/tires' },
+    { name: 'Michelin Tire Pressure Guide', url: 'https://www.michelinman.com/auto/auto-tips-and-advice/tire-pressure' },
+  ],
+  howTo: [
+    { name: 'Enter the reading', text: 'Enter the number shown by your gauge.' },
+    { name: 'Choose the source unit', text: 'Select PSI, bar, kPa or kgf/cm².' },
+    { name: 'Read the conversion', text: 'Use the matching value in the result strip.' },
+  ],
+  schemas,
+};

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

@@ -0,0 +1,96 @@
+import type { WithContext, SoftwareApplication, FAQPage, HowTo } from 'schema-dts';
+import type { SEOSection } from '@jjlmoya/utils-shared';
+import type { TirePressureConverterLocaleContent } from '../entry';
+
+const schemas: WithContext<SoftwareApplication | FAQPage | HowTo>[] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: 'Conversor de Presión de Neumáticos',
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    description: 'Convierte la presión de neumáticos entre PSI, bar, kPa y kgf/cm² fácilmente.',
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: [
+      {
+        '@type': 'Question',
+        name: '¿Qué presión de neumáticos debo utilizar?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Consulta la presión recomendada en frío que figura en la pegatina del marco de la puerta o en el manual del vehículo. El conversor solo transforma las unidades.' },
+      },
+      {
+        '@type': 'Question',
+        name: '¿Por qué pueden ser diferentes las presiones del eje delantero y trasero?',
+        acceptedAnswer: { '@type': 'Answer', text: 'El reparto de pesos del vehículo y la carga sobre cada eje hacen que el fabricante recomiende presiones distintas para el eje delantero y el trasero.' },
+      },
+    ],
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: 'Convertir la presión de un neumático',
+    step: [
+      { '@type': 'HowToStep', name: 'Introduce la lectura', text: 'Escribe el número mostrado por tu manómetro.' },
+      { '@type': 'HowToStep', name: 'Selecciona la unidad de origen', text: 'Elige PSI, bar, kPa o kgf/cm².' },
+      { '@type': 'HowToStep', name: 'Lee la conversión', text: 'Consulta el valor equivalente en el panel de resultados.' },
+    ],
+  },
+];
+
+const seo: SEOSection[] = [
+  { type: 'title', level: 2, text: 'Convierte la presión del neumático sin modificar la lectura real' },
+  { type: 'paragraph', html: 'Utiliza este conversor de presión de neumáticos cuando el manómetro de la estación de servicio o la pegatina del vehículo utilicen unidades distintas a las habituales. Introduce una cifra y obtén la equivalencia simultánea en PSI, bar, kPa y kgf/cm².' },
+  { type: 'title', text: 'Cómo utilizar el conversor', level: 3 },
+  { type: 'list', items: ['Introduce la presión indicada en el manómetro.', 'Selecciona la unidad escrita junto a la lectura.', 'Elige el eje Delantero, Trasero o Ambos ejes para organizar tu anotación.', 'Consulta la cifra equivalente en el panel de conversión.'] },
+  { type: 'tip', title: 'El conversor no determina la presión recomendada de tu coche', html: 'Busca la presión adecuada en frío en el manual del propietario o en la etiqueta del pilar de la puerta. El número grabado en el flanco del neumático indica el límite máximo soportado por la cubierta, no la presión recomendada para tu vehículo.' },
+  { type: 'title', text: 'Unidades de presión de un vistazo', level: 3 },
+  { type: 'table', headers: ['Unidad', 'Significado', 'Relación exacta'], rows: [['PSI', 'Libras por pulgada cuadrada', '1 psi'], ['bar', 'Bar (unidad barométrica)', '1 bar = 14.5037738 psi'], ['kPa', 'Kilopascal', '1 kPa = 0.145037738 psi'], ['kgf/cm²', 'Kilogramo-fuerza por centímetro cuadrado', '1 kgf/cm² = 14.2233433 psi']] },
+  { type: 'diagnostic', variant: 'warning', title: 'Verifica las condiciones de la medición', badge: 'Medición en frío', html: 'La presión varía con la temperatura. Para una medición fiable, sigue las instrucciones del fabricante midiendo siempre el neumático en frío y con un manómetro calibrado.' },
+];
+
+export const content: TirePressureConverterLocaleContent = {
+  slug: 'conversor-presion-neumaticos-psi-bar-kpa-kgf-cm2',
+  title: 'Conversor de Presión de Neumáticos',
+  description: 'Convierte la presión de tus neumáticos entre PSI, bar, kPa y kgf/cm² para coche y moto con notas por eje.',
+  ui: {
+    flowLabel: 'Puente de conversión de presión',
+    flowHint: 'Introduce la lectura disponible, elige la unidad de origen y obtén la equivalencia directa.',
+    readingLabel: 'Lectura del manómetro',
+    readingHint: 'Introduce el valor numérico que muestra tu manómetro o la etiqueta.',
+    sourceUnitLabel: 'Unidad de origen',
+    axleLabel: 'Anotación de eje',
+    frontAxle: 'Delantero',
+    rearAxle: 'Trasero',
+    allAxles: 'Todos los ejes',
+    conversionLabel: 'Presión equivalente',
+    psiLabel: 'PSI',
+    barLabel: 'bar',
+    kpaLabel: 'kPa',
+    kgfcm2Label: 'kgf/cm²',
+    readyMessage: 'Conversión calculada para',
+    emptyMessage: 'Introduce un valor de presión para calcular las equivalencias.',
+    safetyNote: 'Esta herramienta convierte unidades. Consulta el manual de tu vehículo para conocer la presión recomendada en frío.',
+    inputPlaceholder: 'ej. 32',
+  },
+  seo,
+  faqTitle: 'Preguntas sobre conversión de presión de neumáticos',
+  faq: [
+    { question: '¿Qué presión de neumáticos debo utilizar?', answer: 'Consulta la presión recomendada en frío en la pegatina de la puerta o en el manual del vehículo. Esta herramienta solo convierte la unidad de medida.' },
+    { question: '¿Por qué pueden variar las presiones entre ejes?', answer: 'El reparto de pesos y la carga sobre cada eje hacen que los fabricantes indiquen presiones diferentes para las ruedas delanteras y traseras.' },
+    { question: '¿La presión marcada en el neumático es la recomendada?', answer: 'No. La cifra en el flanco de la cubierta es la presión máxima que soporta el neumático. Utiliza siempre la recomendación del fabricante del vehículo.' },
+  ],
+  bibliographyTitle: 'Fuentes',
+  bibliography: [
+    { name: 'DGT Recomendaciones sobre presión de neumáticos', url: 'https://www.dgt.es' },
+    { name: 'Guía Michelin sobre presión de neumáticos', url: 'https://www.michelin.es/auto/consejos-auto/presion-neumaticos' },
+  ],
+  howTo: [
+    { name: 'Introduce la lectura', text: 'Escribe el número mostrado por tu manómetro.' },
+    { name: 'Selecciona la unidad de origen', text: 'Elige PSI, bar, kPa o kgf/cm².' },
+    { name: 'Lee la conversión', text: 'Consulta el valor equivalente en el panel de resultados.' },
+  ],
+  schemas,
+};