@jjlmoya/utils-motor 1.2.0 → 1.3.0

package/src/tool/carMotorcycleGearRatioCalculator/component.astro

@@ -0,0 +1,137 @@
+---
+import type { CarMotorcycleGearRatioCalculatorUI } from './ui';
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const ui = Astro.props.ui as CarMotorcycleGearRatioCalculatorUI;
+const initialValues = {
+  vehicle: 'car',
+  engineRpm: 3000,
+  redlineRpm: 7000,
+  primaryRatio: 1,
+  finalDriveRatio: 4,
+  wheelDiameter: 600,
+  targetSpeed: 90,
+  gearRatios: [3.2, 2.1, 1.4, 1, 0.8, 0.65],
+};
+---
+
+<div class="gear-tool" data-gear-tool>
+  <script is:inline type="application/json" data-gear-ui set:html={JSON.stringify(ui)}></script>
+  <script is:inline type="application/json" data-gear-initial set:html={JSON.stringify(initialValues)}></script>
+
+  <div class="gear-tool-intro">
+    <span class="tool-kicker">{ui.transmissionSceneLabel}</span>
+    <p>{ui.editInputsHint}</p>
+  </div>
+
+  <div class="gear-layout">
+    <section class="gear-controls" aria-label={ui.gearStackLabel}>
+      <div class="control-block control-block-profile">
+          <div class="control-heading">
+            <span>{ui.vehicleProfileLabel}</span>
+            <span class="control-note" data-active-profile>{ui.carLabel}</span>
+          </div>
+          <div class="profile-chips" role="group" aria-label={ui.vehicleProfileLabel}>
+            <button type="button" class="profile-chip is-active" data-profile="car">
+              <span class="profile-chip-mark">C</span>{ui.carPresetLabel}
+            </button>
+            <button type="button" class="profile-chip" data-profile="motorcycle">
+              <span class="profile-chip-mark">M</span>{ui.motorcyclePresetLabel}
+            </button>
+          </div>
+      </div>
+
+      <div class="control-block control-block-units">
+        <div class="control-heading">
+          <span>{ui.unitsLabel}</span>
+          <span class="unit-switch" role="group" aria-label={ui.unitsLabel}>
+            <button type="button" class="unit-button is-active" data-unit="metric">{ui.metricLabel}</button>
+            <button type="button" class="unit-button" data-unit="imperial">{ui.imperialLabel}</button>
+          </span>
+        </div>
+      </div>
+
+      <div class="control-grid">
+        <label class="input-field">
+          <span>{ui.engineRpmLabel}</span>
+          <span class="input-with-unit"><input type="number" min="500" max="16000" step="100" value={initialValues.engineRpm} data-field="engineRpm" /><b>RPM</b></span>
+        </label>
+        <label class="input-field">
+          <span>{ui.redlineLabel}</span>
+          <span class="input-with-unit"><input type="number" min="1500" max="20000" step="100" value={initialValues.redlineRpm} data-field="redlineRpm" /><b>RPM</b></span>
+        </label>
+        <label class="input-field">
+          <span>{ui.primaryRatioLabel}</span>
+          <span class="input-with-unit"><input type="number" min="0.1" max="10" step="0.01" value={initialValues.primaryRatio} data-field="primaryRatio" /><b>{ui.ratioUnit}</b></span>
+        </label>
+        <label class="input-field">
+          <span>{ui.finalDriveLabel}</span>
+          <span class="input-with-unit"><input type="number" min="0.1" max="10" step="0.01" value={initialValues.finalDriveRatio} data-field="finalDriveRatio" /><b>{ui.ratioUnit}</b></span>
+        </label>
+        <label class="input-field">
+          <span>{ui.wheelDiameterLabel}</span>
+          <span class="input-with-unit"><input type="number" min="200" max="1200" step="1" value={initialValues.wheelDiameter} data-field="wheelDiameter" /><b data-wheel-unit>{ui.wheelUnitMetric}</b></span>
+        </label>
+        <label class="input-field">
+          <span>{ui.targetSpeedLabel}</span>
+          <span class="input-with-unit"><input type="number" min="1" max="400" step="1" value={initialValues.targetSpeed} data-field="targetSpeed" /><b data-speed-unit>{ui.speedUnitMetric}</b></span>
+        </label>
+      </div>
+
+      <div class="control-block gear-stack-block">
+        <div class="control-heading">
+          <span>{ui.gearStackLabel}</span>
+          <span class="control-note">{ui.gearRatioHint}</span>
+        </div>
+        <div class="gear-input-grid">
+          {initialValues.gearRatios.map((ratio, index) => (
+            <label class="gear-input">
+              <span>{ui.gearLabel} {index + 1}</span>
+              <input type="number" min="0.1" max="8" step="0.01" value={ratio} data-gear={index} aria-label={`${ui.gearLabel} ${index + 1}`} />
+            </label>
+          ))}
+        </div>
+      </div>
+
+      <button type="button" class="reset-button" data-reset>{ui.resetLabel}</button>
+    </section>
+
+    <section class="gear-visual" aria-label={ui.transmissionSceneLabel}>
+      <div class="transmission-scene">
+        <svg class="scene-svg" viewBox="0 0 760 420" role="img" aria-label={ui.transmissionSceneLabel}>
+          <path class="scene-road" d="M20 345H740" />
+          <path class="scene-shaft" data-shaft-speed d="M74 190H590" />
+          <circle class="scene-engine" cx="78" cy="190" r="52" />
+          <circle class="scene-engine-core" cx="78" cy="190" r="18" />
+          <circle class="scene-gear scene-gear-large" data-gear-rotation="primary" cx="244" cy="190" r="84" />
+          <circle class="scene-gear scene-gear-mid" data-gear-rotation="selected" cx="366" cy="190" r="61" />
+          <circle class="scene-gear scene-gear-small" data-gear-rotation="final" cx="468" cy="190" r="39" />
+          <path class="scene-final-drive" d="M509 190L585 190" />
+          <circle class="scene-wheel" data-wheel-rotation cx="654" cy="190" r="104" />
+          <circle class="scene-wheel-inner" cx="654" cy="190" r="70" />
+          <path class="scene-spoke" d="M654 120V260M584 190H724M605 141L703 239M703 141L605 239" />
+          <text x="52" y="300">{ui.engineLabel}</text>
+          <text x="300" y="300">{ui.gearboxLabel}</text>
+          <text x="608" y="300">{ui.wheelLabel}</text>
+        </svg>
+        <div class="scene-readout" data-scene-readout></div>
+        <div class="motion-hint">
+          <strong>{ui.motionHintLabel}</strong>
+          <span>{ui.motionHintText}</span>
+        </div>
+      </div>
+    </section>
+  </div>
+
+  <section class="gear-results" data-results aria-label={ui.transmissionSceneLabel}></section>
+  <p class="educational-notice">{ui.educationalNotice}</p>
+</div>
+
+<script>
+  import { initializeGearRatioCalculator } from './controller';
+
+  initializeGearRatioCalculator();
+</script>

package/src/tool/carMotorcycleGearRatioCalculator/controller.ts

@@ -0,0 +1,209 @@
+import { evaluateTransmission } from './evaluator';
+import { renderResults } from './dom-views';
+import {
+  calculateTransmission,
+  convertSpeed,
+  convertWheelDiameter,
+  type TransmissionInputs,
+  type UnitSystem,
+} from './logic';
+import { loadSettings, saveSettings, type StoredSettings } from './storage';
+import type { CarMotorcycleGearRatioCalculatorUI } from './ui';
+
+type VehicleProfile = 'car' | 'motorcycle';
+
+interface UnitFieldOptions {
+  root: HTMLElement;
+  field: string;
+  value: number | undefined;
+  fallback: number;
+  unitSystem: UnitSystem;
+  formatter: (value: number, unitSystem: UnitSystem) => number;
+}
+
+interface Preset {
+  vehicle: VehicleProfile;
+  engineRpm: number;
+  redlineRpm: number;
+  primaryRatio: number;
+  finalDriveRatio: number;
+  wheelDiameter: number;
+  targetSpeed: number;
+  gearRatios: number[];
+}
+
+const presets: Record<VehicleProfile, Preset> = {
+  car: {
+    vehicle: 'car', engineRpm: 3000, redlineRpm: 7000, primaryRatio: 1,
+    finalDriveRatio: 4, wheelDiameter: 600, targetSpeed: 90, gearRatios: [3.2, 2.1, 1.4, 1, 0.8, 0.65],
+  },
+  motorcycle: {
+    vehicle: 'motorcycle', engineRpm: 5000, redlineRpm: 11000, primaryRatio: 1.9,
+    finalDriveRatio: 2.8, wheelDiameter: 660, targetSpeed: 90, gearRatios: [2.7, 1.9, 1.45, 1.15, 0.95, 0.8],
+  },
+};
+
+export function initializeGearRatioCalculator(): void {
+  const root = document.querySelector<HTMLElement>('[data-gear-tool]');
+  if (!root) return;
+  const ui = readUi(root);
+  const loaded = loadSettings();
+  const stored = loaded.vehicleProfile === undefined ? {} : loaded;
+  const unitSystem = stored.unitSystem ?? 'metric';
+  const vehicle: VehicleProfile = stored.vehicleProfile ?? 'car';
+  applySettings(root, stored, unitSystem);
+  setActiveProfile(root, ui, vehicle);
+  bindEvents(root, ui);
+  refresh(root, ui, unitSystem);
+}
+
+function readUi(root: HTMLElement): CarMotorcycleGearRatioCalculatorUI {
+  const node = root.querySelector('[data-gear-ui]');
+  return JSON.parse(node?.textContent ?? '{}') as CarMotorcycleGearRatioCalculatorUI;
+}
+
+function applySettings(root: HTMLElement, stored: Partial<StoredSettings>, unitSystem: UnitSystem): void {
+  const defaults = presets.car;
+  setStoredField(root, 'engineRpm', stored.engineRpm, defaults.engineRpm);
+  setStoredField(root, 'redlineRpm', stored.redlineRpm, defaults.redlineRpm);
+  setStoredField(root, 'primaryRatio', stored.primaryRatio, defaults.primaryRatio);
+  setStoredField(root, 'finalDriveRatio', stored.finalDriveRatio, defaults.finalDriveRatio);
+  setUnitField({ root, field: 'wheelDiameter', value: stored.wheelDiameter, fallback: defaults.wheelDiameter, unitSystem, formatter: displayedWheelValue });
+  setUnitField({ root, field: 'targetSpeed', value: stored.targetSpeed, fallback: defaults.targetSpeed, unitSystem, formatter: displayedSpeedValue });
+  const gearRatios = stored.gearRatios ?? presets.car.gearRatios;
+  gearRatios.forEach((ratio, index) => setGear(root, index, ratio));
+  updateUnitLabels(root, unitSystem);
+}
+
+function bindEvents(
+  root: HTMLElement,
+  ui: CarMotorcycleGearRatioCalculatorUI,
+): void {
+  root.addEventListener('input', () => refresh(root, ui, currentUnit(root)));
+  root.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    const profile = target.closest<HTMLElement>('[data-profile]')?.dataset.profile as VehicleProfile | undefined;
+    const unit = target.closest<HTMLElement>('[data-unit]')?.dataset.unit as UnitSystem | undefined;
+    if (profile) selectProfile(root, ui, profile);
+    if (unit) selectUnit(root, ui, unit);
+    if (target.closest('[data-reset]')) resetTool(root, ui);
+  });
+}
+
+function selectProfile(root: HTMLElement, ui: CarMotorcycleGearRatioCalculatorUI, profile: VehicleProfile): void {
+  const preset = presets[profile];
+  const unitSystem = currentUnit(root);
+  setField(root, 'engineRpm', preset.engineRpm);
+  setField(root, 'redlineRpm', preset.redlineRpm);
+  setField(root, 'primaryRatio', preset.primaryRatio);
+  setField(root, 'finalDriveRatio', preset.finalDriveRatio);
+  setField(root, 'wheelDiameter', displayedWheelValue(preset.wheelDiameter, unitSystem));
+  setField(root, 'targetSpeed', displayedSpeedValue(preset.targetSpeed, unitSystem));
+  preset.gearRatios.forEach((ratio, index) => setGear(root, index, ratio));
+  root.querySelectorAll('[data-profile]').forEach((button) => button.classList.toggle('is-active', button.getAttribute('data-profile') === profile));
+  setActiveProfile(root, ui, profile);
+  refresh(root, ui, currentUnit(root));
+}
+
+function selectUnit(root: HTMLElement, ui: CarMotorcycleGearRatioCalculatorUI, next: UnitSystem): void {
+  const current = currentUnit(root);
+  if (current !== next) {
+    const wheel = readNumber(root, 'wheelDiameter');
+    const speed = readNumber(root, 'targetSpeed');
+    setField(root, 'wheelDiameter', roundValue(convertWheelDiameter(wheel, current, next), next === 'metric' ? 0 : 1));
+    setField(root, 'targetSpeed', roundValue(convertSpeed(speed, current, next), next === 'metric' ? 0 : 1));
+  }
+  updateUnitLabels(root, next);
+  refresh(root, ui, next);
+}
+
+function resetTool(root: HTMLElement, ui: CarMotorcycleGearRatioCalculatorUI): void {
+  updateUnitLabels(root, 'metric');
+  selectProfile(root, ui, 'car');
+  refresh(root, ui, 'metric');
+}
+
+function refresh(root: HTMLElement, ui: CarMotorcycleGearRatioCalculatorUI, unitSystem: UnitSystem): void {
+  const inputs = readInputs(root, unitSystem);
+  const result = calculateTransmission(inputs);
+  const evaluation = evaluateTransmission(inputs, result);
+  renderResults(root, { ui, inputs, result, evaluation });
+  saveSettings({ ...inputs, vehicleProfile: currentProfile(root) } as StoredSettings);
+}
+
+function readInputs(root: HTMLElement, unitSystem: UnitSystem): TransmissionInputs {
+  const gearRatios = Array.from(root.querySelectorAll<HTMLInputElement>('[data-gear]')).map((input) => Number(input.value));
+  return {
+    engineRpm: readNumber(root, 'engineRpm'),
+    redlineRpm: readNumber(root, 'redlineRpm'),
+    primaryRatio: readNumber(root, 'primaryRatio'),
+    finalDriveRatio: readNumber(root, 'finalDriveRatio'),
+    wheelDiameter: readNumber(root, 'wheelDiameter'),
+    targetSpeed: readNumber(root, 'targetSpeed'),
+    unitSystem,
+    gearRatios,
+  };
+}
+
+function updateUnitLabels(root: HTMLElement, unitSystem: UnitSystem): void {
+  root.querySelectorAll('[data-unit]').forEach((button) => button.classList.toggle('is-active', button.getAttribute('data-unit') === unitSystem));
+  const wheel = root.querySelector<HTMLElement>('[data-wheel-unit]');
+  const speed = root.querySelector<HTMLElement>('[data-speed-unit]');
+  if (wheel) wheel.textContent = unitSystem === 'metric' ? 'mm' : 'in';
+  if (speed) speed.textContent = unitSystem === 'metric' ? 'km/h' : 'mph';
+}
+
+function currentUnit(root: HTMLElement): UnitSystem {
+  return root.querySelector<HTMLElement>('[data-unit].is-active')?.dataset.unit === 'imperial' ? 'imperial' : 'metric';
+}
+
+function currentProfile(root: HTMLElement): VehicleProfile {
+  return root.querySelector<HTMLElement>('[data-profile].is-active')?.dataset.profile === 'motorcycle' ? 'motorcycle' : 'car';
+}
+
+function setActiveProfile(root: HTMLElement, ui: CarMotorcycleGearRatioCalculatorUI, profile: VehicleProfile): void {
+  root.querySelectorAll('[data-profile]').forEach((button) => button.classList.toggle('is-active', button.getAttribute('data-profile') === profile));
+  const profileLabel = root.querySelector<HTMLElement>('[data-active-profile]');
+  if (profileLabel) profileLabel.textContent = profile === 'car' ? ui.carLabel : ui.motorcycleLabel;
+}
+
+function readNumber(root: HTMLElement, field: string): number {
+  const input = root.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+  const value = Number(input?.value);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+function setField(root: HTMLElement, field: string, value: number): void {
+  const input = root.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+  if (input) input.value = String(value);
+}
+
+function setStoredField(root: HTMLElement, field: string, value: number | undefined, fallback: number): void {
+  setField(root, field, value === undefined ? fallback : value);
+}
+
+function setUnitField(options: UnitFieldOptions): void {
+  const { root, field, value, fallback, unitSystem, formatter } = options;
+  const rawValue = value === undefined ? formatter(fallback, unitSystem) : roundValue(value, unitSystem === 'metric' ? 0 : 1);
+  setField(root, field, rawValue);
+}
+
+function setGear(root: HTMLElement, index: number, value: number): void {
+  const input = root.querySelector<HTMLInputElement>(`[data-gear="${index}"]`);
+  if (input) input.value = String(value);
+}
+
+function displayedWheelValue(value: number, unitSystem: UnitSystem): number {
+  const converted = convertWheelDiameter(value, 'metric', unitSystem);
+  return roundValue(converted, unitSystem === 'metric' ? 0 : 1);
+}
+
+function displayedSpeedValue(value: number, unitSystem: UnitSystem): number {
+  const converted = convertSpeed(value, 'metric', unitSystem);
+  return roundValue(converted, unitSystem === 'metric' ? 0 : 1);
+}
+
+function roundValue(value: number, decimals: number): number {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}

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

@@ -0,0 +1,121 @@
+import type { CarMotorcycleGearRatioCalculatorUI } from './ui';
+import type { CalculationEvaluation } from './evaluator';
+import type { TransmissionInputs, TransmissionResult } from './logic';
+
+interface ViewContext {
+  ui: CarMotorcycleGearRatioCalculatorUI;
+  inputs: TransmissionInputs;
+  result: TransmissionResult;
+  evaluation: CalculationEvaluation;
+}
+
+export function renderResults(root: HTMLElement, context: ViewContext): void {
+  const result = root.querySelector<HTMLElement>('[data-results]');
+  if (!result) return;
+  result.innerHTML = buildResultsMarkup(context);
+  renderScene(root, context);
+}
+
+function buildResultsMarkup(context: ViewContext): string {
+  const { ui, inputs, result, evaluation } = context;
+  const selected = result.gears.find((gear) => gear.gear === evaluation.selectedGear);
+  return `
+    <div class="results-head">
+      <div>
+        <span class="eyebrow">${ui.speedAtRpmLabel}</span>
+        <strong>${formatValue(selected?.speed ?? 0)} ${speedUnit(inputs)}</strong>
+        <span class="results-context">${selected ? `${ui.gearLabel} ${selected.gear} · ${formatRatio(selected.gearRatio)}:1` : '-'}</span>
+      </div>
+      <span class="status-badge status-${evaluation.tone}">${ui[evaluation.messageKey]}</span>
+    </div>
+    ${selected ? buildAnswerMarkup(selected, inputs, ui) : ''}
+    <div class="ladder-heading">
+      <span>${ui.gearStackLabel}</span>
+      <small>${ui.chooseGearHint}</small>
+    </div>
+    <div class="gear-result-list" role="list" aria-label="${ui.gearStackLabel}">
+      ${result.gears.map((gear) => buildGearRow(gear, inputs, ui, gear.gear === evaluation.selectedGear)).join('')}
+    </div>
+  `;
+}
+
+function buildAnswerMarkup(
+  selected: TransmissionResult['gears'][number],
+  inputs: TransmissionInputs,
+  ui: CarMotorcycleGearRatioCalculatorUI,
+): string {
+  return `
+    <div class="answer-card">
+      <span class="eyebrow">${ui.decisionLabel}</span>
+      <div class="answer-grid">
+        <div class="answer-primary">
+          <span>${ui.decisionCruiseLabel}</span>
+          <strong>${formatValue(selected.rpmAtTarget)} <small>RPM</small></strong>
+          <b>${formatValue(inputs.targetSpeed)} ${speedUnit(inputs)} ${ui.targetSpeedMarkerLabel}</b>
+        </div>
+        <div class="answer-secondary">
+          <span>${ui.overallRatioLabel}</span>
+          <strong>${formatRatio(selected.overallRatio)}<small>:1</small></strong>
+          <b>${formatValue(selected.wheelRpm)} ${ui.wheelRpmLabel}</b>
+        </div>
+      </div>
+      <p>${ui.decisionHelper}</p>
+    </div>
+  `;
+}
+
+function buildGearRow(
+  gear: TransmissionResult['gears'][number],
+  inputs: TransmissionInputs,
+  ui: CarMotorcycleGearRatioCalculatorUI,
+  active: boolean,
+): string {
+  const activeClass = active ? ' gear-row-active' : '';
+  return `
+    <div class="gear-row${activeClass}" role="listitem">
+      <span class="gear-number">${ui.gearLabel} ${gear.gear}</span>
+      <span class="gear-ratio">${formatRatio(gear.gearRatio)}:1</span>
+      <span class="gear-speed"><b>${formatValue(gear.speed)}</b> ${speedUnit(inputs)}</span>
+      <span class="gear-rpm"><b>${formatValue(gear.rpmAtTarget)}</b> RPM</span>
+    </div>
+  `;
+}
+
+function renderScene(root: HTMLElement, context: ViewContext): void {
+  const scene = root.querySelector<HTMLElement>('[data-scene-readout]');
+  if (!scene) return;
+  const selected = context.result.gears.find((gear) => gear.gear === context.evaluation.selectedGear);
+  scene.innerHTML = `
+    <span class="scene-label">${context.ui.transmissionSceneLabel}</span>
+    <div class="scene-readout-row">
+      <span>${context.ui.engineLabel}<b>${formatValue(context.inputs.engineRpm)} RPM</b></span>
+      <span>${context.ui.gearboxLabel}<b>${selected ? `${context.ui.gearLabel} ${selected.gear} · ${formatRatio(selected.gearRatio)}:1` : '-'}</b></span>
+      <span>${context.ui.wheelLabel}<b>${formatValue(selected?.speed ?? 0)} ${speedUnit(context.inputs)}</b></span>
+    </div>
+  `;
+  updateSceneGeometry(root, context);
+}
+
+function updateSceneGeometry(root: HTMLElement, context: ViewContext): void {
+  const selected = context.result.gears.find((gear) => gear.gear === context.evaluation.selectedGear);
+  const wheel = root.querySelector<HTMLElement>('[data-wheel-rotation]');
+  const shaft = root.querySelector<HTMLElement>('[data-shaft-speed]');
+  const engineFactor = Math.max(context.inputs.engineRpm, 500) / 6000;
+  const wheelFactor = Math.max(selected?.speed ?? 0, 5) / 120;
+  root.style.setProperty('--engine-duration', `${Math.max(0.6, 2.8 / engineFactor)}s`);
+  root.style.setProperty('--wheel-duration', `${Math.max(0.7, 3.4 / wheelFactor)}s`);
+  if (wheel) wheel.style.setProperty('--wheel-speed', `${Math.min(selected?.speed ?? 0, 240) / 240}`);
+  if (shaft) shaft.style.setProperty('--shaft-speed', `${Math.min(context.inputs.engineRpm, 12000) / 12000}`);
+}
+
+function speedUnit(inputs: TransmissionInputs): string {
+  return inputs.unitSystem === 'metric' ? 'km/h' : 'mph';
+}
+
+function formatValue(value: number): string {
+  return new Intl.NumberFormat('en', { maximumFractionDigits: 1 }).format(value);
+}
+
+function formatRatio(value: number): string {
+  return new Intl.NumberFormat('en', { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(value);
+}

package/src/tool/carMotorcycleGearRatioCalculator/entry.ts

@@ -0,0 +1,30 @@
+import type { MotorToolEntry, ToolLocaleContent } from '../../types';
+import type { CarMotorcycleGearRatioCalculatorUI } from './ui';
+
+export type { CarMotorcycleGearRatioCalculatorUI };
+export type CarMotorcycleGearRatioCalculatorLocaleContent = ToolLocaleContent<CarMotorcycleGearRatioCalculatorUI>;
+
+export const carMotorcycleGearRatioCalculator: MotorToolEntry<CarMotorcycleGearRatioCalculatorUI> = {
+  id: 'car-motorcycle-gear-ratio-rpm-speed-calculator',
+  icons: {
+    bg: 'mdi:car-cog',
+    fg: 'mdi:transmission-tower',
+  },
+  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/carMotorcycleGearRatioCalculator/evaluator.ts

@@ -0,0 +1,28 @@
+import type { TransmissionInputs } from './logic';
+import type { TransmissionResult } from './logic';
+
+export type CalculationTone = 'normal' | 'warning' | 'critical';
+
+export interface CalculationEvaluation {
+  tone: CalculationTone;
+  messageKey: 'readyMessage' | 'highRpmMessage' | 'lowRpmMessage' | 'invalidMessage';
+  selectedGear: number;
+}
+
+export function evaluateTransmission(
+  inputs: TransmissionInputs,
+  result: TransmissionResult,
+): CalculationEvaluation {
+  if (result.gears.length === 0 || result.gears.some((gear) => !Number.isFinite(gear.speed))) {
+    return { tone: 'critical', messageKey: 'invalidMessage', selectedGear: 0 };
+  }
+  const targetGear = result.gears.find((gear) => gear.gear === result.selectedGear);
+  if (!targetGear) return { tone: 'critical', messageKey: 'invalidMessage', selectedGear: 0 };
+  if (targetGear.rpmAtTarget > inputs.redlineRpm) {
+    return { tone: 'critical', messageKey: 'highRpmMessage', selectedGear: targetGear.gear };
+  }
+  if (targetGear.rpmAtTarget < 1200) {
+    return { tone: 'warning', messageKey: 'lowRpmMessage', selectedGear: targetGear.gear };
+  }
+  return { tone: 'normal', messageKey: 'readyMessage', selectedGear: targetGear.gear };
+}