@jjlmoya/utils-motor 1.2.0 → 1.3.0

package/src/tool/carMotorcycleGearRatioCalculator/storage.ts

@@ -0,0 +1,46 @@
+import type { TransmissionInputs, UnitSystem } from './logic';
+
+const STORAGE_KEY = 'car-motorcycle-gear-ratio-rpm-speed-calculator';
+
+export interface StoredSettings extends Omit<TransmissionInputs, 'unitSystem'> {
+  unitSystem: UnitSystem;
+  vehicleProfile?: 'car' | 'motorcycle';
+}
+
+export function loadSettings(): Partial<StoredSettings> {
+  try {
+    const value = window.localStorage.getItem(STORAGE_KEY);
+    if (!value) return {};
+    const parsed: unknown = JSON.parse(value);
+    return isStoredSettings(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function saveSettings(settings: StoredSettings): void {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+  } catch {
+  }
+}
+
+function isStoredSettings(value: unknown): value is StoredSettings {
+  if (!value || typeof value !== 'object') return false;
+  const candidate = value as Partial<StoredSettings>;
+  if (!isUnitSystem(candidate.unitSystem)) return false;
+  if (!isVehicleProfile(candidate.vehicleProfile)) return false;
+  return isNumberArray(candidate.gearRatios);
+}
+
+function isUnitSystem(value: unknown): value is UnitSystem {
+  return value === 'metric' || value === 'imperial';
+}
+
+function isVehicleProfile(value: unknown): value is 'car' | 'motorcycle' | undefined {
+  return value === undefined || value === 'car' || value === 'motorcycle';
+}
+
+function isNumberArray(value: unknown): value is number[] {
+  return Array.isArray(value) && value.every((ratio) => typeof ratio === 'number');
+}

package/src/tool/carMotorcycleGearRatioCalculator/ui.ts

@@ -0,0 +1,50 @@
+export interface CarMotorcycleGearRatioCalculatorUI extends Record<string, string> {
+  unitsLabel: string;
+  metricLabel: string;
+  imperialLabel: string;
+  vehicleProfileLabel: string;
+  carLabel: string;
+  motorcycleLabel: string;
+  carPresetLabel: string;
+  motorcyclePresetLabel: string;
+  engineRpmLabel: string;
+  redlineLabel: string;
+  primaryRatioLabel: string;
+  finalDriveLabel: string;
+  wheelDiameterLabel: string;
+  targetSpeedLabel: string;
+  gearStackLabel: string;
+  gearRatioHint: string;
+  gearLabel: string;
+  transmissionSceneLabel: string;
+  motionHintLabel: string;
+  motionHintText: string;
+  engineLabel: string;
+  gearboxLabel: string;
+  finalDriveShortLabel: string;
+  wheelLabel: string;
+  speedAtRpmLabel: string;
+  rpmAtTargetLabel: string;
+  overallRatioLabel: string;
+  wheelRpmLabel: string;
+  targetSpeedMarkerLabel: string;
+  selectedGearLabel: string;
+  decisionLabel: string;
+  decisionSpeedLabel: string;
+  decisionCruiseLabel: string;
+  decisionHelper: string;
+  chooseGearHint: string;
+  editInputsHint: string;
+  calculationStatusLabel: string;
+  readyMessage: string;
+  highRpmMessage: string;
+  lowRpmMessage: string;
+  invalidMessage: string;
+  resetLabel: string;
+  educationalNotice: string;
+  ratioUnit: string;
+  speedUnitMetric: string;
+  speedUnitImperial: string;
+  wheelUnitMetric: string;
+  wheelUnitImperial: string;
+}

package/src/tool/tirePressureConverter/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliographyEntries } from './bibliography';
+---
+
+<SharedBibliography links={bibliographyEntries} />

package/src/tool/tirePressureConverter/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliographyEntries: BibliographyEntry[] = [
+  {
+    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',
+  },
+];

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,
+};