@jjlmoya/utils-chrono 1.22.0 → 1.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-chrono",
-    "version": "1.22.0",
+    "version": "1.24.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/layouts/PreviewLayout.astro

@@ -78,7 +78,7 @@ const { title, currentLocale = "es", localeUrls = {}, hasSidebar = false } = Ast
     transition:
       background-color 0.3s ease,
       color 0.3s ease;
-  }
+    font-family: Inter, sans-serif;}
 
   main {
     padding: 0 2rem;

package/src/tests/diacritics_density.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type LocaleWithDiacritics = keyof typeof DIACRITIC_RULES;
+
+const DIACRITIC_RULES = {
+  de: {
+    language: 'German',
+    expectedCharacters: 'ä ö ü ß',
+    characters: /[äöüÄÖÜß]/g,
+    minPerThousandLetters: 0.1,
+  },
+  es: {
+    language: 'Spanish',
+    expectedCharacters: 'á é í ó ú ü ñ',
+    characters: /[áéíóúüñÁÉÍÓÚÜÑ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  fr: {
+    language: 'French',
+    expectedCharacters: 'à â æ ç é è ê ë î ï ô œ ù û ü ÿ',
+    characters: /[àâæçéèêëîïôœùûüÿÀÂÆÇÉÈÊËÎÏÔŒÙÛÜŸ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  it: {
+    language: 'Italian',
+    expectedCharacters: 'à è é ì í î ò ó ù ú',
+    characters: /[àèéìíîòóùúÀÈÉÌÍÎÒÓÙÚ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pl: {
+    language: 'Polish',
+    expectedCharacters: 'ą ć ę ł ń ó ś ź ż',
+    characters: /[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pt: {
+    language: 'Portuguese',
+    expectedCharacters: 'á â ã à ç é ê í ó ô õ ú ü',
+    characters: /[áâãàçéêíóôõúüÁÂÃÀÇÉÊÍÓÔÕÚÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  sv: {
+    language: 'Swedish',
+    expectedCharacters: 'å ä ö',
+    characters: /[åäöÅÄÖ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  tr: {
+    language: 'Turkish',
+    expectedCharacters: 'ç ğ ı İ ö ş ü',
+    characters: /[çğıöşüÇĞİÖŞÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+} 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 diacriticCount(text: string, locale: LocaleWithDiacritics): number {
+  return text.match(DIACRITIC_RULES[locale].characters)?.length ?? 0;
+}
+
+function diacriticsPerThousandLetters(text: string, locale: LocaleWithDiacritics): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return diacriticCount(text, locale) / letters * 1000;
+}
+
+describe('Diacritics density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(DIACRITIC_RULES).forEach((locale) => {
+        it(`${locale} keeps the expected accent and special-letter set`, async () => {
+          const typedLocale = locale as LocaleWithDiacritics;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const rule = DIACRITIC_RULES[typedLocale];
+          const letters = letterCount(text);
+          const matches = diacriticCount(text, typedLocale);
+          const density = diacriticsPerThousandLetters(text, typedLocale);
+
+          expect(
+            density,
+            [
+              `Possible spelling or encoding issue detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} special characters (${density.toFixed(2)} per 1000 letters, ${letters} letters analyzed).`,
+              `This locale should include some of these characters: ${rule.expectedCharacters}.`,
+              'If the count is 0 or near 0, accents, tildes, or special letters were probably stripped by encoding or normalization.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minPerThousandLetters);
+        });
+      });
+    });
+  });
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const INVERTED_PUNCTUATION_LOCALES = {
+  es: {
+    language: 'Spanish',
+    questionStart: '¿',
+    questionEnd: '?',
+    exclamationStart: '¡',
+    exclamationEnd: '!',
+  },
+} as const;
+
+type InvertedPunctuationLocale = keyof typeof INVERTED_PUNCTUATION_LOCALES;
+
+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 translatableStrings(content: Record<string, unknown>): string[] {
+  return TRANSLATABLE_KEYS.flatMap((key) => collectStrings(content[key]));
+}
+
+function sentenceStart(text: string, endIndex: number): string {
+  const beforeMark = text.slice(0, endIndex).trimEnd();
+  const boundary = Math.max(
+    beforeMark.lastIndexOf('.'),
+    beforeMark.lastIndexOf(':'),
+    beforeMark.lastIndexOf(';'),
+    beforeMark.lastIndexOf('\n'),
+  );
+
+  return beforeMark.slice(boundary + 1).trimStart();
+}
+
+function findMissingInvertedMarks(
+  text: string,
+  startMark: string,
+  endMark: string,
+): string[] {
+  return [...text.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+    .map((match) => sentenceStart(text, match.index ?? 0))
+    .filter((segment) => segment.length > 0 && !segment.includes(startMark))
+    .map((segment) => `${segment}${endMark}`);
+}
+
+describe('Inverted punctuation validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(INVERTED_PUNCTUATION_LOCALES).forEach((locale) => {
+        it(`${locale} uses opening punctuation marks for questions and exclamations`, async () => {
+          const typedLocale = locale as InvertedPunctuationLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
+          const content = await loader();
+          const strings = translatableStrings(content as Record<string, unknown>);
+          const missingQuestions = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
+          );
+          const missingExclamations = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd)
+          );
+          const failures = [...missingQuestions, ...missingExclamations];
+
+          expect(
+            failures,
+            [
+              `Missing opening punctuation marks in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `Questions must use ${rule.questionStart}...${rule.questionEnd} and exclamations must use ${rule.exclamationStart}...${rule.exclamationEnd}.`,
+              `Examples: ${failures.slice(0, 5).join(' | ')}`,
+            ].join(' '),
+          ).toHaveLength(0);
+        });
+      });
+    });
+  });
+});

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/gear-train-explorer/client.ts

@@ -1,5 +1,6 @@
 const canvas = document.getElementById('gear-canvas') as HTMLCanvasElement;
 const ctx = canvas.getContext('2d')!;
+const root = canvas.closest('.gear-train-card') || document;
 
 import { MOVEMENTS } from './movements';
 import type { MovementDef } from './movements';
@@ -34,17 +35,17 @@ function resizeCanvas() {
 
 function updateStats() {
   const g = currentMov.gears;
-  const setText = (id: string, v: string) => { const el = document.getElementById('rpm-' + id); if (el) el.textContent = v; };
+  const setText = (id: string, v: string) => { const el = root.querySelector('#rpm-' + id); if (el) el.textContent = v; };
   setText('barrel', (g[0].rpm * 60).toFixed(2) + '/h');
   setText('center', (g[1].rpm * 60).toFixed(1) + '/h');
   setText('third', (g[2].rpm * 60).toFixed(1) + '/h');
   setText('fourth', g[3].rpm.toFixed(1) + ' rpm');
   setText('escape', g[4].rpm.toFixed(0) + ' rpm');
-  const bphEl = document.getElementById('bph-pallet');
+  const bphEl = root.querySelector('#bph-pallet');
   if (bphEl) bphEl.textContent = currentMov.pallet.bph.toString();
-  const hzEl = document.getElementById('hz-balance');
+  const hzEl = root.querySelector('#hz-balance');
   if (hzEl) hzEl.textContent = currentMov.balance.hz.toString();
-  const vphEl = document.getElementById('vph-balance');
+  const vphEl = root.querySelector('#vph-balance');
   if (vphEl) vphEl.textContent = currentMov.balance.vph.toString();
 }
 
@@ -53,7 +54,7 @@ function render() {
   setHovered(hoveredGear);
   drawScene(currentMov, { angles, palletPhase, balancePhase, highlight: highlightedGear, hover: hoveredGear });
   const step = highlightedGear !== null ? highlightedGear : -1;
-  document.querySelectorAll('.flow-bar .step').forEach((el, idx) => {
+  root.querySelectorAll('.flow-bar .step').forEach((el, idx) => {
     el.classList.toggle('active', idx <= step);
   });
 }
@@ -83,7 +84,7 @@ function switchMovement(id: string) {
   balancePhase = 0;
   highlightedGear = null;
   updateStats();
-  document.querySelectorAll('[data-mov]').forEach((b) => {
+  root.querySelectorAll('[data-mov]').forEach((b) => {
     b.classList.toggle('active', (b as HTMLElement).dataset.mov === id);
   });
 }
@@ -91,7 +92,7 @@ function switchMovement(id: string) {
 function setSpeed(mult: number) {
   speedMult = mult;
   paused = mult === 0;
-  document.querySelectorAll('[data-spd]').forEach((b) => {
+  root.querySelectorAll('[data-spd]').forEach((b) => {
     const spd = parseFloat((b as HTMLElement).dataset.spd || '1');
     b.classList.toggle('active', spd === mult);
   });
@@ -118,20 +119,20 @@ function onCanvasMove(e: MouseEvent) {
 function highlightGear(idx: number | null) {
   hoveredGear = idx;
   highlightedGear = idx;
-  document.querySelectorAll('.data-card').forEach((c) => c.classList.remove('highlighted'));
+  root.querySelectorAll('.data-card').forEach((c) => c.classList.remove('highlighted'));
   if (idx !== null && idx < 7) {
-    document.querySelectorAll('.data-card')[idx]?.classList.add('highlighted');
+    root.querySelectorAll('.data-card')[idx]?.classList.add('highlighted');
   }
 }
 
 function initControls() {
-  document.querySelectorAll('[data-mov]').forEach((b) => {
+  root.querySelectorAll('[data-mov]').forEach((b) => {
     b.addEventListener('click', () => switchMovement((b as HTMLElement).dataset.mov || '2824'));
   });
-  document.querySelectorAll('[data-spd]').forEach((b) => {
+  root.querySelectorAll('[data-spd]').forEach((b) => {
     b.addEventListener('click', () => setSpeed(parseFloat((b as HTMLElement).dataset.spd || '1')));
   });
-  document.querySelectorAll('.data-card').forEach((card, idx) => {
+  root.querySelectorAll('.data-card').forEach((card, idx) => {
     card.addEventListener('mouseenter', () => highlightGear(idx));
     card.addEventListener('mouseleave', () => highlightGear(null));
   });

package/src/tool/gear-train-explorer/component.astro

@@ -10,7 +10,7 @@ const { ui } = Astro.props;
 
 <link href="./gear-train-explorer.css" rel="stylesheet" />
 
-<div class="tool-main-card" data-ui={JSON.stringify(ui)}>
+<div class="gear-train-card" data-ui={JSON.stringify(ui)}>
   <GearPanel labels={ui} />
 </div>
 

package/src/tool/gear-train-explorer/gear-train-explorer.css

@@ -1,4 +1,4 @@
-.tool-main-card {
+.gear-train-card {
   background: var(--bg-surface);
   border: 1px solid var(--border-color);
   border-radius: 1.25rem;
@@ -10,32 +10,32 @@
   box-shadow: var(--shadow-base);
 }
 
-.canvas-wrapper {
+.gear-train-card .canvas-wrapper {
   background: radial-gradient(ellipse at center, #1a1a2e 0%, #0f0f1a 100%);
   border-radius: 0.75rem;
   overflow: hidden;
   border: 1px solid rgba(212, 175, 55, 0.15);
 }
 
-canvas#gear-canvas {
+.gear-train-card canvas#gear-canvas {
   display: block;
   width: 100%;
   height: auto;
 }
 
-.controls-row {
+.gear-train-card .controls-row {
   display: flex;
   flex-wrap: wrap;
   gap: 0.75rem;
 }
 
-.control-group {
+.gear-train-card .control-group {
   display: flex;
   flex-direction: column;
   gap: 0.2rem;
 }
 
-.control-label {
+.gear-train-card .control-label {
   font-size: 0.6rem;
   font-weight: 600;
   text-transform: uppercase;
@@ -44,12 +44,12 @@ canvas#gear-canvas {
   opacity: 0.5;
 }
 
-.control-group .btn-group {
+.gear-train-card .control-group .btn-group {
   display: flex;
   gap: 0.25rem;
 }
 
-.control-group .btn-group button {
+.gear-train-card .control-group .btn-group button {
   padding: 0.25rem 0.55rem;
   font-size: 0.7rem;
   font-weight: 500;
@@ -61,25 +61,25 @@ canvas#gear-canvas {
   transition: all 0.2s ease;
 }
 
-.control-group .btn-group button:hover {
+.gear-train-card .control-group .btn-group button:hover {
   border-color: var(--accent);
   color: var(--accent);
 }
 
-.control-group .btn-group button.active {
+.gear-train-card .control-group .btn-group button.active {
   background: color-mix(in srgb, var(--accent) 10%, var(--bg-page));
   border-color: var(--accent);
   color: var(--accent);
   box-shadow: 0 0 8px color-mix(in srgb, var(--accent) 12%, transparent);
 }
 
-.data-grid {
+.gear-train-card .data-grid {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(95px, 1fr));
   gap: 0.35rem;
 }
 
-.data-card {
+.gear-train-card .data-card {
   background: var(--bg-page);
   border: 1px solid var(--border-base);
   border-radius: 0.5rem;
@@ -88,17 +88,17 @@ canvas#gear-canvas {
   cursor: default;
 }
 
-.data-card:hover {
+.gear-train-card .data-card:hover {
   border-color: var(--accent);
 }
 
-.data-card.highlighted {
+.gear-train-card .data-card.highlighted {
   border-color: var(--accent);
   background: color-mix(in srgb, var(--accent) 6%, var(--bg-page));
   box-shadow: 0 0 10px color-mix(in srgb, var(--accent) 8%, transparent);
 }
 
-.data-card .name {
+.gear-train-card .data-card .name {
   font-size: 0.65rem;
   font-weight: 600;
   text-transform: uppercase;
@@ -107,33 +107,33 @@ canvas#gear-canvas {
   margin-bottom: 0.15rem;
 }
 
-.data-card .stats {
+.gear-train-card .data-card .stats {
   display: flex;
   gap: 0.35rem;
   flex-wrap: wrap;
 }
 
-.data-card .stats span {
+.gear-train-card .data-card .stats span {
   font-size: 0.65rem;
   color: var(--text-base);
   opacity: 0.75;
 }
 
-.data-card .stats .val {
+.gear-train-card .data-card .stats .val {
   color: var(--accent);
   font-weight: 600;
   font-variant-numeric: tabular-nums;
   opacity: 1;
 }
 
-.flow-bar {
+.gear-train-card .flow-bar {
   background: var(--bg-page);
   border: 1px solid var(--border-base);
   border-radius: 0.5rem;
   padding: 0.4rem 0.6rem;
 }
 
-.flow-bar .flow-label {
+.gear-train-card .flow-bar .flow-label {
   font-size: 0.6rem;
   font-weight: 600;
   text-transform: uppercase;
@@ -143,14 +143,14 @@ canvas#gear-canvas {
   margin-bottom: 0.2rem;
 }
 
-.flow-bar .flow-path {
+.gear-train-card .flow-bar .flow-path {
   display: flex;
   align-items: center;
   gap: 0.2rem;
   flex-wrap: wrap;
 }
 
-.flow-bar .flow-path .step {
+.gear-train-card .flow-bar .flow-path .step {
   font-size: 0.65rem;
   color: var(--text-base);
   opacity: 0.4;
@@ -159,14 +159,39 @@ canvas#gear-canvas {
   transition: all 0.25s ease;
 }
 
-.flow-bar .flow-path .step.active {
+.gear-train-card .flow-bar .flow-path .step.active {
   opacity: 1;
   color: var(--accent);
   background: color-mix(in srgb, var(--accent) 8%, var(--bg-page));
 }
 
-.flow-bar .flow-path .arrow {
+.gear-train-card .flow-bar .flow-path .arrow {
   color: var(--text-base);
   opacity: 0.2;
   font-size: 0.7rem;
 }
+
+@media (max-width: 520px) {
+  .gear-train-card {
+    padding: 0.875rem;
+    max-width: 100%;
+    overflow: hidden;
+  }
+
+  .gear-train-card .canvas-wrapper {
+    width: 100%;
+  }
+
+  .gear-train-card .control-group,
+  .gear-train-card .control-group .btn-group {
+    width: 100%;
+  }
+
+  .gear-train-card .control-group .btn-group {
+    flex-wrap: wrap;
+  }
+
+  .gear-train-card .control-group .btn-group button {
+    flex: 1 1 auto;
+  }
+}

package/src/tool/mainspring-finder/i18n/es.ts

@@ -5,7 +5,7 @@ import { bibliography } from '../bibliography';
 export const content: ToolLocaleContent<MainspringFinderUI> = {
   slug: 'buscador-muelle-real',
   title: 'Buscador de Muelle Real',
-  description: 'Calcule las dimensiones del muelle real a partir de las medidas del barrilete para movimientos de reloj antiguos.',
+  description: 'Calcule las dimensiones del muelle real a partir de las medidas del barrilete para movimientos de reloj antiguos con precisión, diámetro y árbol correctos.',
   ui: {
     title: 'Buscador de Muelle Real',
     barrelLabel: 'DI del Barrilete',
@@ -90,23 +90,23 @@ export const content: ToolLocaleContent<MainspringFinderUI> = {
   ],
   faq: [
     {
-      question: 'Que precision tienen las dimensiones calculadas del muelle real?',
+      question: '¿Que precision tienen las dimensiones calculadas del muelle real?',
       answer: 'Los calculos se basan en formulas estandar de relojeria que asumen una geometria ideal del barrilete. Las dimensiones reales pueden variar hasta un 5-10 % debido a las tolerancias de fabricacion, las configuraciones del extremo del muelle (anclaje, ojal o extremo en T) y la aleacion especifica utilizada. Utilice siempre los valores calculados como un punto de referencia solido, pero compare con las hojas de datos del fabricante o los catalogos de proveedores comerciales antes de hacer su pedido.',
     },
     {
-      question: 'Que sucede si no encuentro el tamano comercial exacto?',
+      question: '¿Que sucede si no encuentro el tamano comercial exacto?',
       answer: 'Cuando el tamano exacto no esta disponible, priorice coincidir exactamente con la altura del muelle, luego el grosor dentro de 0.005 mm. La longitud se puede ajustar seleccionando un muelle diferente de la misma familia de altura y grosor. Un muelle ligeramente mas largo funcionara si el barrilete tiene suficiente espacio, pero un muelle mas corto reducira la reserva de marcha.',
     },
     {
-      question: 'Como mido las dimensiones del barrilete sin quitar el muelle real?',
+      question: '¿Como mido las dimensiones del barrilete sin quitar el muelle real?',
       answer: 'Si el barrilete aun contiene el muelle viejo, puede medir el diametro exterior del barrilete desde fuera (luego reste el grosor de la pared, tipicamente 0.2-0.4 mm) y la altura total (luego reste el grosor de la tapa). Para obtener los resultados mas precisos, retire el muelle viejo y limpie el barrilete antes de medir.',
     },
     {
-      question: 'Cual es la diferencia entre un extremo de muelle de anclaje y uno de ojal?',
+      question: '¿Cual es la diferencia entre un extremo de muelle de anclaje y uno de ojal?',
       answer: 'Un extremo de anclaje (tambien llamado extremo en T) tiene una pequena lengueta en forma de T que se engancha en la pared del barrilete. La mayoria de los calibres suizos y japoneses modernos usan este tipo. Un extremo de ojal tiene un pequeno agujero que se ajusta sobre una clavija en el arbol. Esta herramienta calcula solo las dimensiones de la cinta; debe verificar que el tipo de extremo coincida con su barrilete antes de hacer su pedido.',
     },
     {
-      question: 'Puedo usar esta herramienta para movimientos automaticos o cronografos?',
+      question: '¿Puedo usar esta herramienta para movimientos automaticos o cronografos?',
       answer: 'Si, pero tenga en cuenta que los movimientos automaticos a menudo tienen un numero mayor de vueltas (8-10) y pueden requerir un muelle ligeramente mas delgado para acomodar el modulo de cuerda adicional. Los movimientos de cronografo tipicamente necesitan muelles mas gruesos para accionar el mecanismo del cronografo. Ajuste el valor de Vueltas en consecuencia y verifique contra las especificaciones del fabricante.',
     },
   ],

package/src/tool/mainspring-finder/i18n/it.ts

@@ -5,7 +5,7 @@ import { bibliography } from '../bibliography';
 export const content: ToolLocaleContent<MainspringFinderUI> = {
   slug: 'trova-molla-reale',
   title: 'Trova Molla Reale',
-  description: 'Calcola le dimensioni della molla reale a partire dalle misure del bariletto per movimenti di orologi vintage.',
+  description: 'Calcola le dimensioni della molla reale a partire dalle misure del bariletto per movimenti di orologi vintage; è utile per più verifiche di compatibilità.',
   ui: {
     title: 'Trova Molla Reale',
     barrelLabel: 'Diametro interno bariletto',