@jjlmoya/utils-nautical 1.16.0 → 1.18.0

package/src/tests/pagespeed_best_practices.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join, relative } from 'path';
+import { ALL_TOOLS } from '../tools';
+import type { SEOSection, ToolLocaleContent } from '../types';
+
+const srcDir = join(process.cwd(), 'src');
+const toolDir = join(srcDir, 'tool');
+const geometryReads = [
+  'offsetWidth',
+  'offsetHeight',
+  'offsetTop',
+  'offsetLeft',
+  'clientWidth',
+  'clientHeight',
+  'clientTop',
+  'clientLeft',
+  'scrollWidth',
+  'scrollHeight',
+  'scrollTop',
+  'scrollLeft',
+  'getBoundingClientRect',
+  'getClientRects',
+  'computedStyle',
+  'getComputedStyle',
+];
+const domWrites = [
+  '.style.',
+  '.classList.add',
+  '.classList.remove',
+  '.classList.toggle',
+  '.appendChild',
+  '.insertBefore',
+  '.prepend',
+  '.append',
+  '.remove',
+  '.innerHTML',
+  '.textContent',
+  '.setAttribute',
+];
+
+function findFiles(dir: string, extensions: string[]): string[] {
+  const files: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...findFiles(fullPath, extensions));
+    else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(fullPath);
+  }
+  return files;
+}
+
+function relativePath(file: string): string {
+  return relative(process.cwd(), file).replace(/\\/g, '/');
+}
+
+function findFormControls(content: string, tagName: 'input' | 'select'): RegExpMatchArray[] {
+  return Array.from(content.matchAll(new RegExp(`<${tagName}\\b[^>]*>`, 'gi')));
+}
+
+function attrValue(tag: string, attr: string): string | null {
+  const match = tag.match(new RegExp(`\\b${attr}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{([^}]+)\\})`, 'i'));
+  return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+
+function booleanAttr(tag: string, attr: string): boolean {
+  return new RegExp(`\\b${attr}\\b`, 'i').test(tag);
+}
+
+function controlStartIndex(content: string, tag: RegExpMatchArray): number {
+  return tag.index ?? content.indexOf(tag[0]);
+}
+
+function hasWrappingLabel(content: string, tag: RegExpMatchArray): boolean {
+  const index = controlStartIndex(content, tag);
+  const before = content.slice(0, index);
+  const labelOpen = before.lastIndexOf('<label');
+  const labelClose = before.lastIndexOf('</label>');
+  const nextLabelClose = content.indexOf('</label>', index + tag[0].length);
+  return labelOpen > labelClose && nextLabelClose !== -1;
+}
+
+function hasAccessibleName(content: string, tag: RegExpMatchArray): boolean {
+  const source = tag[0];
+  if (attrValue(source, 'aria-label')) return true;
+  if (attrValue(source, 'aria-labelledby')) return true;
+  const id = attrValue(source, 'id');
+  if (id && hasExplicitLabel(content, id)) return true;
+  return hasWrappingLabel(content, tag);
+}
+
+function isVisuallyHiddenFileInput(tag: string): boolean {
+  const type = attrValue(tag, 'type')?.toLowerCase() ?? 'text';
+  const attributes = `${attrValue(tag, 'style') ?? ''} ${attrValue(tag, 'class') ?? ''}`.toLowerCase();
+  const hiddenPatterns = ['display:none', 'display: none', 'file-input'];
+  return type === 'file' && hiddenPatterns.some((pattern) => attributes.includes(pattern));
+}
+
+function isIgnoredInput(tag: string): boolean {
+  const type = attrValue(tag, 'type')?.toLowerCase() ?? 'text';
+  return ['hidden', 'button', 'submit', 'reset'].includes(type) || booleanAttr(tag, 'aria-hidden') || isVisuallyHiddenFileInput(tag);
+}
+
+function controlFailures(content: string, tagName: 'input' | 'select'): string[] {
+  return findFormControls(content, tagName)
+    .filter((tag) => tagName !== 'input' || !isIgnoredInput(tag[0]))
+    .filter((tag) => !hasAccessibleName(content, tag))
+    .map((tag) => tag[0]);
+}
+
+function explicitLabelMessage(tagName: string, path: string, failures: string[]): string {
+  return `${tagName} controls without label, wrapping label, aria-label or aria-labelledby in ${path}:\n${failures.join('\n')}`;
+}
+
+function hasExplicitLabel(content: string, id: string): boolean {
+  const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return (
+    new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']${escapedId}["'][^>]*>`, 'i').test(content)
+    || new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*\\{${escapedId}\\}[^>]*>`, 'i').test(content)
+  );
+}
+
+function headingLevels(sections: SEOSection[]): number[] {
+  return sections
+    .filter((section) => section.type === 'title')
+    .map((section) => Number('level' in section ? section.level : 0))
+    .filter((level) => Number.isInteger(level) && level > 0);
+}
+
+function findHeadingLevelJumps(levels: number[]): string[] {
+  const failures: string[] = [];
+  levels.forEach((level, index) => {
+    const previous = index === 0 ? 1 : levels[index - 1];
+    if (previous && level > previous + 1) {
+      failures.push(`h${previous} -> h${level}`);
+    }
+  });
+  return failures;
+}
+
+function hasDomWriteBeforeGeometryRead(content: string): boolean {
+  const normalized = content.replace(/\s+/g, ' ');
+  return domWrites.some((write) => {
+    const writeIndex = normalized.indexOf(write);
+    if (writeIndex === -1) return false;
+    return geometryReads.some((read) => normalized.indexOf(read, writeIndex + write.length) !== -1);
+  });
+}
+
+describe('PageSpeed best-practice guards', () => {
+  const astroToolFiles = findFiles(toolDir, ['.astro']);
+  const scriptFiles = findFiles(toolDir, ['.astro', '.ts', '.js']);
+
+  astroToolFiles.forEach((file) => {
+    const displayPath = relativePath(file);
+
+    it(`${displayPath} labels every input with an explicit label`, () => {
+      const content = readFileSync(file, 'utf-8');
+      const failures = controlFailures(content, 'input');
+
+      expect(failures, explicitLabelMessage('Input', displayPath, failures)).toEqual([]);
+    });
+
+    it(`${displayPath} labels every select with an explicit label`, () => {
+      const content = readFileSync(file, 'utf-8');
+      const failures = controlFailures(content, 'select');
+
+      expect(failures, explicitLabelMessage('Select', displayPath, failures)).toEqual([]);
+    });
+  });
+
+  ALL_TOOLS.forEach((tool) => {
+    Object.entries(tool.entry.i18n).forEach(([locale, loader]) => {
+      it(`${tool.entry.id}/${locale} keeps SEO headings sequential`, async () => {
+        if (!loader) return;
+        const content = (await loader()) as ToolLocaleContent;
+        const levels = headingLevels(content.seo);
+        const failures = findHeadingLevelJumps(levels);
+
+        expect(
+          failures,
+          `SEO headings in ${tool.entry.id}/${locale} skip levels: ${failures.join(', ')}`,
+        ).toEqual([]);
+      });
+    });
+  });
+
+  scriptFiles.forEach((file) => {
+    const displayPath = relativePath(file);
+
+    it(`${displayPath} avoids static forced-reflow patterns`, () => {
+      const content = readFileSync(file, 'utf-8');
+      expect(
+        hasDomWriteBeforeGeometryRead(content),
+        `${displayPath} appears to read layout geometry after DOM/style mutations. Split writes and reads across frames or measure before mutating.`,
+      ).toBe(false);
+    });
+  });
+});

package/src/tests/script_density.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});

package/src/tool/endurance/component.astro

@@ -12,10 +12,10 @@ const { ui } = Astro.props;
   <div class="ec-main-container">
     <aside class="ec-sidebar-inputs">
       <div class="ec-compact-group">
-        <label>{ui.tankCapacityLabel}</label>
+        <span class="ec-group-label">{ui.tankCapacityLabel}</span>
         <div class="ec-dual-row">
           <div>
-            <span class="ec-sub-label">{ui.mainTankLabel}</span>
+            <label for="tank1" class="ec-sub-label">{ui.mainTankLabel}</label>
             <div class="ec-field-wrapper">
               <span class="ec-field-icon icon-fuel"></span>
               <input type="number" id="tank1" class="ec-compact-input" value="200" min="0" step="10" />
@@ -23,7 +23,7 @@ const { ui } = Astro.props;
             </div>
           </div>
           <div>
-            <span class="ec-sub-label">{ui.auxTankLabel}</span>
+            <label for="tank2" class="ec-sub-label">{ui.auxTankLabel}</label>
             <div class="ec-field-wrapper">
               <span class="ec-field-icon icon-fuel"></span>
               <input type="number" id="tank2" class="ec-compact-input" value="0" min="0" step="10" />
@@ -34,7 +34,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.currentFuelLabel}</label>
+        <label for="f-current">{ui.currentFuelLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon icon-bucket"></span>
           <input type="number" id="f-current" class="ec-compact-input" value="150" min="0" step="5" />
@@ -43,7 +43,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.seaConditionsLabel}</label>
+        <label for="sea-s">{ui.seaConditionsLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon icon-wave"></span>
           <select id="sea-s" class="ec-compact-select">
@@ -56,7 +56,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.consumptionLabel}</label>
+        <label for="f-cons">{ui.consumptionLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon icon-fire"></span>
           <input type="number" id="f-cons" class="ec-compact-input" value="25" min="0.1" step="1" />
@@ -65,7 +65,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.cruiseSpeedLabel}</label>
+        <label for="v-cruiser">{ui.cruiseSpeedLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon icon-wind"></span>
           <input type="number" id="v-cruiser" class="ec-compact-input" value="8" min="0.1" step="0.5" />
@@ -74,7 +74,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.reserveLabel}</label>
+        <label for="f-res">{ui.reserveLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon icon-shield"></span>
           <input type="number" id="f-res" class="ec-compact-input" value="20" min="0" max="50" step="5" />
@@ -83,7 +83,7 @@ const { ui } = Astro.props;
       </div>
 
       <div class="ec-compact-group">
-        <label>{ui.fuelPriceLabel}</label>
+        <label for="f-price">{ui.fuelPriceLabel}</label>
         <div class="ec-field-wrapper">
           <span class="ec-field-icon">€</span>
           <input type="number" id="f-price" class="ec-compact-input" value="1.8" min="0" step="0.05" />
@@ -137,7 +137,7 @@ const { ui } = Astro.props;
         <div class="ec-inverter-header">{ui.inverseCalcLabel}</div>
         <div class="ec-inverter-row">
           <div>
-            <div class="ec-inverter-label">{ui.desiredDistLabel}</div>
+            <label for="inv-dist" class="ec-inverter-label">{ui.desiredDistLabel}</label>
             <div class="ec-field-wrapper">
               <input type="number" id="inv-dist" class="ec-compact-input" value="50" min="0" step="5" />
               <span class="ec-unit-tag">MN</span>

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

@@ -3,29 +3,29 @@ import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dt
 import type { EnduranceUI, EnduranceLocaleContent } from '../index';
 
 const slug = 'calculadora-autonomia-nautica';
-const title = 'Calculadora de Autonomia Nautica';
+const title = 'Calculadora de Autonomía Náutica';
 const description =
-  'Calcula tu alcance maximo y distancia segura segun consumo, capacidad y velocidad de crucero. Gestion de combustible para embarcaciones a motor.';
+  'Calcula tu alcance máximo y distancia segura según consumo, capacidad y velocidad de crucero. Gestión de combustible para embarcaciones a motor.';
 
 const ui: EnduranceUI = {
-  tankCapacityLabel: 'Capacidad del Deposito',
+  tankCapacityLabel: 'Capacidad del Depósito',
   mainTankLabel: 'Ppal',
   auxTankLabel: 'Aux',
   currentFuelLabel: 'Combustible Actual',
   seaConditionsLabel: 'Condiciones Mar/Viento',
-  consumptionLabel: 'Consumo Teorico',
+  consumptionLabel: 'Consumo Teórico',
   cruiseSpeedLabel: 'Velocidad Crucero',
   reserveLabel: 'Reserva',
   fuelPriceLabel: 'Precio Litro',
-  maxRangeLabel: 'Alcance Maximo',
+  maxRangeLabel: 'Alcance Máximo',
   realPerformanceLabel: 'Rendimiento Real',
-  hoursLabel: 'Autonomia Horas',
+  hoursLabel: 'Autonomía Horas',
   safeMilesLabel: 'Millas Seguras',
   tankValueLabel: 'Valor Tanque',
-  inverseCalcLabel: 'Calculo Inverso: ¿Cuanto necesito repostar?',
+  inverseCalcLabel: 'Calculo Inverso: ¿Cuánto necesito repostar?',
   desiredDistLabel: 'Distancia Deseada',
-  minFuelLabel: 'Combustible Minimo Requerido',
-  warningLabel: 'Recordatorio: Una reserva del 20% es el minimo absoluto recomendado por seguridad nautica.',
+  minFuelLabel: 'Combustible Mínimo Requerido',
+  warningLabel: 'Recordatorio: Una reserva del 20% es el mínimo absoluto recomendado por seguridad náutica.',
   seaCalm: 'Calma (1.0x)',
   seaLight: 'Marejadilla (+15%)',
   seaModerate: 'Marejada (+30%)',
@@ -34,59 +34,59 @@ const ui: EnduranceUI = {
 
 const faq: EnduranceLocaleContent['faq'] = [
   {
-    question: '¿Como se calcula la autonomia de una embarcacion a motor?',
-    answer: 'La autonomia se calcula dividiendo el combustible disponible entre el consumo horario para obtener las horas totales, y multiplicando ese tiempo por la velocidad de crucero. La herramienta aplica ademas un factor de mar para reflejar condiciones reales de navegacion.',
+    question: '¿Cómo se calcula la autonomía de una embarcación a motor?',
+    answer: 'La autonomía se calcula dividiendo el combustible disponible entre el consumo horario para obtener las horas totales, y multiplicando ese tiempo por la velocidad de crucero. La herramienta aplica además un factor de mar para reflejar condiciones reales de navegación.',
   },
   {
-    question: '¿Por que se recomienda una reserva del 20% en nautica?',
-    answer: 'La reserva del 20% es un estandar de seguridad nautica que garantiza combustible suficiente ante imprevistos: corrientes contrarias, rodeos por mal tiempo, fallos en las previsiones de consumo o necesidad de asistir a otra embarcacion. Muchas aseguradoras y capitanias lo consideran obligatorio.',
+    question: '¿Por qué se recomienda una reserva del 20% en náutica?',
+    answer: 'La reserva del 20% es un estándar de seguridad náutica que garantiza combustible suficiente ante imprevistos: corrientes contrarias, rodeos por mal tiempo, fallos en las previsiones de consumo o necesidad de asistir a otra embarcación. Muchas aseguradoras y capitanías lo consideran obligatorio.',
   },
   {
-    question: '¿Que es el rendimiento en L/MN y como afecta a la planificacion?',
-    answer: 'El rendimiento en litros por milla nautica (L/MN) es la eficiencia real del motor en condiciones de mar. A diferencia del consumo horario, permite calcular exactamente cuanto combustible necesitas para recorrer una distancia concreta, independientemente de tu velocidad.',
+    question: '¿Qué es el rendimiento en L/MN y cómo afecta a la planificación?',
+    answer: 'El rendimiento en litros por milla náutica (L/MN) es la eficiencia real del motor en condiciones de mar. A diferencia del consumo horario, permite calcular exactamente cuánto combustible necesitas para recorrer una distancia concreta, independientemente de tu velocidad.',
   },
   {
-    question: '¿Como influye el estado del mar en el consumo real?',
-    answer: 'El estado del mar incrementa el consumo porque el casco trabaja mas contra la resistencia del agua y el viento. En marejadilla el consumo aumenta un 15%, en marejada un 30% y en temporal puede dispararse un 60% o mas. Ignorar este factor puede dejar una embarcacion sin combustible antes de llegar a puerto.',
+    question: '¿Cómo influye el estado del mar en el consumo real?',
+    answer: 'El estado del mar incrementa el consumo porque el casco trabaja más contra la resistencia del agua y el viento. En marejadilla el consumo aumenta un 15%, en marejada un 30% y en temporal puede dispararse un 60% o más. Ignorar este factor puede dejar una embarcación sin combustible antes de llegar a puerto.',
   },
 ];
 
 const howTo: EnduranceLocaleContent['howTo'] = [
   {
-    name: 'Introduce la capacidad de tus depositos',
-    text: 'Indica los litros del deposito principal y del auxiliar si tienes uno. La herramienta calculara el porcentaje de llenado actual.',
+    name: 'Introduce la capacidad de tus depósitos',
+    text: 'Indica los litros del depósito principal y del auxiliar si tienes uno. La herramienta calculará el porcentaje de llenado actual.',
   },
   {
     name: 'Indica el combustible actual',
-    text: 'Introduce los litros reales que tienes en este momento. Puedes medirlos con el nivel del barco o estimarlos segun el ultimo repostaje.',
+    text: 'Introduce los litros reales que tienes en este momento. Puedes medirlos con el nivel del barco o estimarlos según el último repostaje.',
   },
   {
-    name: 'Ajusta las condiciones de navegacion',
-    text: 'Selecciona el estado del mar previsto para tu travesia. El factor de mar corrije el consumo teorico al consumo real esperado.',
+    name: 'Ajusta las condiciones de navegación',
+    text: 'Selecciona el estado del mar previsto para tu travesía. El factor de mar corrige el consumo teórico al consumo real esperado.',
   },
   {
     name: 'Introduce consumo y velocidad de crucero',
-    text: 'Usa los datos del fabricante o tus propios registros de consumo horario y la velocidad a la que navegaras habitualmente.',
+    text: 'Usa los datos del fabricante o tus propios registros de consumo horario y la velocidad a la que navegarás habitualmente.',
   },
   {
-    name: 'Revisa la distancia segura y el calculo inverso',
-    text: 'La herramienta te muestra cuantas millas puedes recorrer con seguridad y cuanto combustible necesitas para llegar a un destino concreto.',
+    name: 'Revisa la distancia segura y el cálculo inverso',
+    text: 'La herramienta te muestra cuántas millas puedes recorrer con seguridad y cuánto combustible necesitas para llegar a un destino concreto.',
   },
 ];
 
 const seo: EnduranceLocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Gestion de Combustible y Autonomia en Navegacion a Motor',
+    text: 'Gestión de Combustible y Autonomía en Navegación a Motor',
     level: 2,
   },
   {
     type: 'paragraph',
-    html: 'La <strong>autonomia nautica</strong> es uno de los calculos mas criticos antes de zarpar en una embarcacion a motor. Conocer con precision cuantas millas puedes recorrer con el combustible disponible es la diferencia entre una travesia planificada y una emergencia en alta mar.',
+    html: 'La <strong>autonomía náutica</strong> es uno de los cálculos más críticos antes de zarpar en una embarcación a motor. Conocer con precisión cuántas millas puedes recorrer con el combustible disponible es la diferencia entre una travesía planificada y una emergencia en alta mar.',
   },
   {
     type: 'paragraph',
-    html: 'Esta calculadora de autonomia integra el <strong>factor de condiciones de mar</strong>, el porcentaje de reserva de seguridad y el calculo inverso de combustible necesario para que la gestion de combustible sea completa y fiable en cualquier situacion.',
+    html: 'Esta calculadora de autonomía integra el <strong>factor de condiciones de mar</strong>, el porcentaje de reserva de seguridad y el cálculo inverso de combustible necesario para que la gestión de combustible sea completa y fiable en cualquier situación.',
   },
   {
     type: 'title',
@@ -95,19 +95,19 @@ const seo: EnduranceLocaleContent['seo'] = [
   },
   {
     type: 'paragraph',
-    html: 'La regla clasica de gestion de combustible en nautica divide el deposito en tres partes iguales para garantizar siempre un margen de seguridad:',
+    html: 'La regla clásica de gestión de combustible en náutica divide el depósito en tres partes iguales para garantizar siempre un margen de seguridad:',
   },
   {
     type: 'list',
     items: [
       '<strong>Un tercio para la ida:</strong> El combustible necesario para llegar al destino previsto.',
-      '<strong>Un tercio para la vuelta:</strong> El combustible de regreso al puerto de salida o al mas cercano.',
+      '<strong>Un tercio para la vuelta:</strong> El combustible de regreso al puerto de salida o al más cercano.',
       '<strong>Un tercio de reserva:</strong> El margen de seguridad ante imprevistos, corrientes o condiciones adversas.',
     ],
   },
   {
     type: 'paragraph',
-    html: 'En la calculadora puedes configurar el porcentaje de reserva segun tu criterio, aunque <strong>nunca se recomienda bajar del 20%</strong>. Con depositos mas grandes o travesias largas, muchos patrones experimentados elevan este margen al 30% o incluso al 33%.',
+    html: 'En la calculadora puedes configurar el porcentaje de reserva según tu criterio, aunque <strong>nunca se recomienda bajar del 20%</strong>. Con depósitos más grandes o travesías largas, muchos patrones experimentados elevan este margen al 30% o incluso al 33%.',
   },
   {
     type: 'title',
@@ -116,30 +116,30 @@ const seo: EnduranceLocaleContent['seo'] = [
   },
   {
     type: 'paragraph',
-    html: 'El consumo teorico del fabricante se calcula en condiciones ideales de laboratorio. En la practica, multiples factores alteran el <strong>consumo real</strong> de combustible. La velocidad de casco es el mas determinante: navegar a velocidades superiores a la velocidad economica puede duplicar o triplicar el consumo por milla recorrida.',
+    html: 'El consumo teórico del fabricante se calcula en condiciones ideales de laboratorio. En la práctica, múltiples factores alteran el <strong>consumo real</strong> de combustible. La velocidad de casco es el más determinante: navegar a velocidades superiores a la velocidad económica puede duplicar o triplicar el consumo por milla recorrida.',
   },
   {
     type: 'table',
-    headers: ['Estado de la Navegacion', 'Efecto en la Autonomia', 'Consejo'],
+    headers: ['Estado de la Navegación', 'Efecto en la Autonomía', 'Consejo'],
     rows: [
-      ['<strong>Casco con Incrustaciones</strong>', 'Reduce la autonomia hasta un 20%', 'Limpia el casco antes de temporada'],
+      ['<strong>Casco con Incrustaciones</strong>', 'Reduce la autonomía hasta un 20%', 'Limpia el casco antes de temporada'],
       ['<strong>Corriente en Contra</strong>', 'Puede reducir la velocidad efectiva un 30%', 'Calcula siempre con la velocidad real sobre el fondo'],
-      ['<strong>Viento de Proa</strong>', 'Aumenta la resistencia y el consumo un 10-25%', 'Usa el factor de marejada o marejada para el calculo'],
+      ['<strong>Viento de Proa</strong>', 'Aumenta la resistencia y el consumo un 10-25%', 'Usa el factor de marejada o marejada para el cálculo'],
       ['<strong>Exceso de Carga</strong>', 'Aumenta el calado y la resistencia', 'Pesa el equipo y provisiones antes de calcular'],
     ],
   },
   {
     type: 'title',
-    text: 'Glosario Tecnica de Autonomia',
+    text: 'Glosario Técnico de Autonomía',
     level: 3,
   },
   {
     type: 'glossary',
     items: [
-      { term: 'Rendimiento (L/MN)', definition: 'Litros de combustible consumidos por cada milla nautica recorrida. Es el indicador mas util para planificar travesias porque relaciona consumo con distancia real.' },
-      { term: 'Velocidad de Crucero', definition: 'La velocidad optima a la que el motor ofrece el mejor equilibrio entre velocidad y consumo. Generalmente entre el 70% y el 80% de la potencia maxima.' },
-      { term: 'Reserva Critica', definition: 'El porcentaje del deposito que nunca debe consumirse. Se recomienda un minimo del 20% para cubrir imprevistos y evitar que entre aire en el circuito de combustible.' },
-      { term: 'Consumo Especifico', definition: 'Gramos de combustible por kilovatio-hora de potencia producida (g/kWh). Medida tecnica del motor que permite comparar la eficiencia entre distintos propulsores.' },
+      { term: 'Rendimiento (L/MN)', definition: 'Litros de combustible consumidos por cada milla náutica recorrida. Es el indicador más útil para planificar travesías porque relaciona consumo con distancia real.' },
+      { term: 'Velocidad de Crucero', definition: 'La velocidad óptima a la que el motor ofrece el mejor equilibrio entre velocidad y consumo. Generalmente entre el 70% y el 80% de la potencia máxima.' },
+      { term: 'Reserva Crítica', definition: 'El porcentaje del depósito que nunca debe consumirse. Se recomienda un mínimo del 20% para cubrir imprevistos y evitar que entre aire en el circuito de combustible.' },
+      { term: 'Consumo Específico', definition: 'Gramos de combustible por kilovatio-hora de potencia producida (g/kWh). Medida técnica del motor que permite comparar la eficiencia entre distintos propulsores.' },
     ],
   },
   {
@@ -149,48 +149,48 @@ const seo: EnduranceLocaleContent['seo'] = [
   },
   {
     type: 'paragraph',
-    html: 'Una fuente habitual de problemas en embarcaciones con poco combustible son los <strong>lodos del fondo del deposito</strong>. Cuando el nivel baja mucho, los sedimentos acumulados durante anos pueden llegar al filtro y taponarlo, dejando el motor sin combustible aunque el nivel marque algunos litros.',
+    html: 'Una fuente habitual de problemas en embarcaciones con poco combustible son los <strong>lodos del fondo del depósito</strong>. Cuando el nivel baja mucho, los sedimentos acumulados durante años pueden llegar al filtro y taponarlo, dejando el motor sin combustible aunque el nivel marque algunos litros.',
   },
   {
     type: 'paragraph',
-    html: 'El movimiento del barco en mar con poco combustible tambien puede causar problemas: el liquido oscila con las olas y puede dejar momentaneamente sin alimentacion a la bomba. Mantener la reserva garantiza que esto no ocurra en un momento critico como una maniobra de entrada a puerto.',
+    html: 'El movimiento del barco en mar con poco combustible también puede causar problemas: el líquido oscila con las olas y puede dejar momentáneamente sin alimentación a la bomba. Mantener la reserva garantiza que esto no ocurra en un momento crítico como una maniobra de entrada a puerto.',
   },
   {
     type: 'tip',
     title: 'Consejo de Ahorro',
-    html: 'Reducir la velocidad entre un 10% y un 15% respecto a la de crucero habitual puede mejorar la eficiencia hasta un 30%. Si tienes tiempo y el tiempo acompana, navegar mas despacio es siempre la decision mas economica y segura.',
+    html: 'Reducir la velocidad entre un 10% y un 15% respecto a la de crucero habitual puede mejorar la eficiencia hasta un 30%. Si tienes tiempo y el tiempo acompaña, navegar más despacio es siempre la decisión más económica y segura.',
   },
   {
     type: 'title',
-    text: 'Diferencia entre Millas Náuticas (MN) y Kilometros',
+    text: 'Diferencia entre Millas Náuticas (MN) y Kilómetros',
     level: 3,
   },
   {
     type: 'paragraph',
-    html: 'Una <strong>milla nautica</strong> equivale a 1.852 metros (1,852 km), y es la unidad de distancia universal en navegacion maritima y aerea. Esta basada en el arco de un minuto de grado geografico, lo que la hace ideal para la navegacion con cartas en coordenadas geograficas. La velocidad en millasnáuticas por hora se denomina nudo (kn).',
+    html: 'Una <strong>milla náutica</strong> equivale a 1.852 metros (1,852 km), y es la unidad de distancia universal en navegación marítima y aérea. Está basada en el arco de un minuto de grado geográfico, lo que la hace ideal para la navegación con cartas en coordenadas geográficas. La velocidad en millas náuticas por hora se denomina nudo (kn).',
   },
   {
     type: 'comparative',
     items: [
       {
-        title: 'Indicador Analogico de Aguja',
+        title: 'Indicador Analógico de Aguja',
         description: 'Sistema tradicional de flotador',
         points: [
-          'Bajo coste y sencillez de instalacion',
+          'Bajo coste y sencillez de instalación',
           'No requiere electricidad para funcionar',
-          'Imprecision en mar movido por el movimiento del combustible',
-          'No muestra consumo ni autonomia estimada',
+          'Imprecisión en mar movido por el movimiento del combustible',
+          'No muestra consumo ni autonomía estimada',
         ],
       },
       {
         title: 'Calculador de Flujo Digital',
-        description: 'Sensores electronicos de caudal',
+        description: 'Sensores electrónicos de caudal',
         highlight: true,
         points: [
-          'Precision del 1-2% en el consumo real',
-          'Muestra autonomia, consumo y coste en tiempo real',
+          'Précisión del 1-2% en el consumo real',
+          'Muestra autonomía, consumo y coste en tiempo real',
           'Integrable con chartplotters y NMEA 2000',
-          'Requiere calibracion inicial y mantenimiento',
+          'Requiere calibración inicial y mantenimiento',
         ],
       },
     ],
@@ -219,7 +219,7 @@ const schemas: EnduranceLocaleContent['schemas'] = [
   {
     '@context': 'https://schema.org',
     '@type': 'HowTo',
-    name: `Como usar: ${title}`,
+    name: `Cómo usar: ${title}`,
     step: howTo.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
   } as WithContext<HowTo>,
 ];