@jjlmoya/utils-diy 1.15.0 → 1.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-diy",
-    "version": "1.15.0",
+    "version": "1.17.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/i18n/fr.ts

@@ -1,4 +1,4 @@
-import type { CategoryLocaleContent } from '../../types';
+import type { CategoryLocaleContent } from '../../types';
 
 export const content: CategoryLocaleContent = {
   slug: 'diy',
@@ -8,7 +8,7 @@ export const content: CategoryLocaleContent = {
   seo: [
     {
       type: 'title',
-      text: 'Ingénierie Domestique et Projets DIY : Du Design à la Réalité',
+      text: 'Ingénierie Domestique et Projets DIY: Du Design à la Réalité',
       level: 2,
     },
     {
@@ -21,7 +21,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Construction et Rénovation : Béton, Mortiers et Escaliers',
+      text: 'Construction et Rénovation: Béton, Mortiers et Escaliers',
       level: 2,
     },
     {
@@ -39,7 +39,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Artisanat et Nouveaux Matériaux : Argile et Résine Époxy',
+      text: 'Artisanat et Nouveaux Matériaux: Argile et Résine Époxy',
       level: 2,
     },
     {
@@ -71,7 +71,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Gestion du Budget : Décomposition des Coûts et Optimisation Économique',
+      text: 'Gestion du Budget: Décomposition des Coûts et Optimisation Économique',
       level: 2,
     },
     {

package/src/entries.ts

@@ -16,6 +16,7 @@ export { thermalExpansionCalculator } from './tool/thermalExpansionCalculator/en
 export { voltageDropCalculator } from './tool/voltageDropCalculator/entry';
 export { workshopFractionConverter } from './tool/workshopFractionConverter/entry';
 export { pythagoreanRightAngleCalculator } from './tool/pythagoreanRightAngleCalculator/entry';
+export { twoStrokeMixtureCalculator } from './tool/twoStrokeMixtureCalculator/entry';
 export { diyCategory } from './category';
 import { balusterCalculator } from './tool/balusterCalculator/entry';
 import { clayCalculator } from './tool/clayCalculator/entry';
@@ -32,4 +33,5 @@ import { thermalExpansionCalculator } from './tool/thermalExpansionCalculator/en
 import { voltageDropCalculator } from './tool/voltageDropCalculator/entry';
 import { workshopFractionConverter } from './tool/workshopFractionConverter/entry';
 import { pythagoreanRightAngleCalculator } from './tool/pythagoreanRightAngleCalculator/entry';
-export const ALL_ENTRIES = [balusterCalculator, clayCalculator, concreteCalculator, cutOptimizer, drillCalculator, drillSharpener, epoxyCalculator, furnitureFit, mortarCalculator, passepartoutCalculator, stairCalculator, thermalExpansionCalculator, voltageDropCalculator, workshopFractionConverter, pythagoreanRightAngleCalculator];
+import { twoStrokeMixtureCalculator } from './tool/twoStrokeMixtureCalculator/entry';
+export const ALL_ENTRIES = [balusterCalculator, clayCalculator, concreteCalculator, cutOptimizer, drillCalculator, drillSharpener, epoxyCalculator, furnitureFit, mortarCalculator, passepartoutCalculator, stairCalculator, thermalExpansionCalculator, voltageDropCalculator, workshopFractionConverter, pythagoreanRightAngleCalculator, twoStrokeMixtureCalculator];

package/src/index.ts

@@ -46,3 +46,5 @@ export { DRILL_SHARPENER_TOOL } from './tool/drillSharpener/index';
 export { WORKSHOP_FRACTION_CONVERTER_TOOL } from './tool/workshopFractionConverter/index';
 
 export { PYTHAGOREAN_RIGHT_ANGLE_CALCULATOR_TOOL } from './tool/pythagoreanRightAngleCalculator/index';
+
+export { TWO_STROKE_MIXTURE_CALCULATOR_TOOL } from './tool/twoStrokeMixtureCalculator/index';

package/src/layouts/PreviewLayout.astro

@@ -78,6 +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 {

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/locale_completeness.test.ts

@@ -33,8 +33,8 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('all 15 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(15);
+  it('all 16 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(16);
   });
 });
 

package/src/tests/no_en_dash.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getFiles(dir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) {
+    return results;
+  }
+  const list = fs.readdirSync(dir);
+  for (const file of list) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat && stat.isDirectory()) {
+      if (file !== 'tests' && file !== 'node_modules' && file !== '.astro') {
+        results.push(...getFiles(fullPath));
+      }
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function isContentFile(filePath: string): boolean {
+  return /\\i18n\\/.test(filePath) || filePath.endsWith('bibliography.ts');
+}
+
+const srcDir = path.join(process.cwd(), 'src');
+const scriptsDir = path.join(process.cwd(), 'scripts');
+const filesToTest = [
+  ...getFiles(srcDir).filter(isContentFile),
+  ...getFiles(scriptsDir).filter(isContentFile),
+];
+
+const aiTypographyGarbage = [
+  '\u2013',
+  '\u2014',
+  '\u2026',
+  '\u201C',
+  '\u201D',
+  '\u2018',
+  '\u2019',
+  '\u00AB',
+  '\u00BB',
+  '\u200B',
+  '\u201E',
+];
+
+describe('Typography Garbage Character Validation', () => {
+  filesToTest.forEach((filePath) => {
+    const relativePath = path.relative(process.cwd(), filePath);
+    it(`should not contain typography garbage characters in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const hasAiPatterns = aiTypographyGarbage.some(char => content.includes(char));
+      expect(hasAiPatterns).toBe(false);
+    });
+
+    it(`should not contain space before colon in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const spaceBeforeColon = / : /.test(content);
+      expect(spaceBeforeColon).toBe(false);
+    });
+
+    it(`should not contain double hyphen in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).not.toContain('--');
+    });
+  });
+});

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/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { diyCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 15 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(15);
+    it('should have 16 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(16);
     });
 
     it('diyCategory should be defined', () => {

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

@@ -1,4 +1,4 @@
-import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
 import type { ToolLocaleContent } from '../../../types';
 import type { BalusterCalculatorUI } from '../ui';
 import { bibliography } from '../bibliography';
@@ -116,7 +116,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
     },
     {
       type: 'paragraph',
-      html: 'Bevor Sie das erste Stück Holz oder Metall schneiden, müssen Sie das „Warum“ hinter der Mathematik verstehen. Die Bauvorschriften in vielen Ländern, wie auch der IRC (International Residential Code) in den USA, legen eine klare Norm fest: <em>„Der lichte Abstand zwischen vertikalen Elementen darf den Durchgang einer Kugel mit 10 cm (4 Zoll) Durchmesser nicht zulassen.“</em>',
+      html: 'Bevor Sie das erste Stück Holz oder Metall schneiden, müssen Sie das "Warum" hinter der Mathematik verstehen. Die Bauvorschriften in vielen Ländern, wie auch der IRC (International Residential Code) in den USA, legen eine klare Norm fest: <em>"Der lichte Abstand zwischen vertikalen Elementen darf den Durchgang einer Kugel mit 10 cm (4 Zoll) Durchmesser nicht zulassen."</em>',
     },
     {
       type: 'paragraph',
@@ -129,7 +129,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
     },
     {
       type: 'paragraph',
-      html: 'In der Programmierung und im Bauwesen gibt es ein klassisches Problem namens <em>„Fencepost Error“</em> (Zaunpfostenfehler). Wenn Sie einen 10 Meter langen Zaun mit Pfosten alle 1 Meter bauen wollen, wie viele Pfosten benötigen Sie? Die intuitive Antwort ist 10, aber die richtige ist 11.',
+      html: 'In der Programmierung und im Bauwesen gibt es ein klassisches Problem namens <em>"Fencepost Error"</em> (Zaunpfostenfehler). Wenn Sie einen 10 Meter langen Zaun mit Pfosten alle 1 Meter bauen wollen, wie viele Pfosten benötigen Sie? Die intuitive Antwort ist 10, aber die richtige ist 11.',
     },
     {
       type: 'paragraph',
@@ -148,7 +148,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
           type: 'card',
           icon: 'mdi:function-variant',
           title: 'Schritt B: Exakten Abstand neuberechnen',
-          html: '<p class="bc-formula">g = (L - n × w) / (n + 1)</p><p>Sobald wir die exakte Anzahl der Baluster (n) kennen, berechnen wir, wie viel Platz „übrig bleibt“, wenn wir die Breite des gesamten Materials abziehen, und verteilen diesen gleichmäßig auf die Lücken (n+1).</p>',
+          html: '<p class="bc-formula">g = (L - n × w) / (n + 1)</p><p>Sobald wir die exakte Anzahl der Baluster (n) kennen, berechnen wir, wie viel Platz "übrig bleibt", wenn wir die Breite des gesamten Materials abziehen, und verteilen diesen gleichmäßig auf die Lücken (n+1).</p>',
         },
       ],
     },
@@ -212,7 +212,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
       type: 'card',
       icon: 'mdi:help-circle-outline',
       title: 'Was passiert, wenn die letzte Lücke nicht passt?',
-      html: '<p>Wenn Sie unseren Rechner verwendet haben, sollte dies nicht passieren. In der realen Welt verbiegt sich jedoch Holz, und Pfosten sind nicht immer gerade. Wenn Ihnen am Ende 1-2 mm fehlen oder zu viel sind, ist das unmerklich. Wenn Ihnen 1 cm fehlt, überprüfen Sie Ihre Abstandshalter; wahrscheinlich haben Sie sich bei jedem Schritt Millimeter „eingefressen“.</p>',
+      html: '<p>Wenn Sie unseren Rechner verwendet haben, sollte dies nicht passieren. In der realen Welt verbiegt sich jedoch Holz, und Pfosten sind nicht immer gerade. Wenn Ihnen am Ende 1-2 mm fehlen oder zu viel sind, ist das unmerklich. Wenn Ihnen 1 cm fehlt, überprüfen Sie Ihre Abstandshalter; wahrscheinlich haben Sie sich bei jedem Schritt Millimeter "eingefressen".</p>',
     },
     {
       type: 'card',
@@ -224,13 +224,13 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
       type: 'card',
       icon: 'mdi:wrench-outline',
       title: 'Holz, Metall oder Glas?',
-      html: '<p>Dieser Rechner funktioniert für <strong>jedes sich wiederholende vertikale Element</strong>. Wenn Sie horizontale Stahlseile verwenden, sind die Vorschriften anders (normalerweise dürfen sie nicht zum Klettern einladen, „Leitereffekt“). Bei Glas wird es als durchgehende Platte betrachtet, und es gilt kein Abstand, sondern die Schlagfestigkeit.</p>',
+      html: '<p>Dieser Rechner funktioniert für <strong>jedes sich wiederholende vertikale Element</strong>. Wenn Sie horizontale Stahlseile verwenden, sind die Vorschriften anders (normalerweise dürfen sie nicht zum Klettern einladen, "Leitereffekt"). Bei Glas wird es als durchgehende Platte betrachtet, und es gilt kein Abstand, sondern die Schlagfestigkeit.</p>',
     },
     {
       type: 'card',
       icon: 'mdi:format-quote-close',
       title: 'Mies van der Rohe',
-      html: '<p><em>„Architektur ist der Wille der Epoche, in den Raum übersetzt.“</em></p><p>Wir hoffen, dass dieses Tool Ihnen hilft, sicherere und schönere Räume zu bauen. Denken Sie immer daran, die örtlichen Bauvorschriften Ihrer Gemeinde zu konsultieren, da es spezifische Variationen bei der Mindesthöhe (normalerweise 90–110 cm) oder den Belastungen geben kann.</p>',
+      html: '<p><em>"Architektur ist der Wille der Epoche, in den Raum übersetzt."</em></p><p>Wir hoffen, dass dieses Tool Ihnen hilft, sicherere und schönere Räume zu bauen. Denken Sie immer daran, die örtlichen Bauvorschriften Ihrer Gemeinde zu konsultieren, da es spezifische Variationen bei der Mindesthöhe (normalerweise 90-110 cm) oder den Belastungen geben kann.</p>',
     },
   ],
   ui: {

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

@@ -1,4 +1,4 @@
-import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
 import type { ToolLocaleContent } from '../../../types';
 import type { BalusterCalculatorUI } from '../ui';
 import { bibliography } from '../bibliography';
@@ -120,7 +120,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
     },
     {
       type: 'paragraph',
-      html: "This measurement is not arbitrary. It is the average diameter of a young child's head (generally under 1 year old). If a child can fit their body through but their head gets stuck, the risk of suffocation is extremely high. If they can fit their head through, they can fall into the void. Therefore, the goal of our <strong>Baluster Calculator</strong> is not just aesthetic — it saves lives.",
+      html: "This measurement is not arbitrary. It is the average diameter of a young child's head (generally under 1 year old). If a child can fit their body through but their head gets stuck, the risk of suffocation is extremely high. If they can fit their head through, they can fall into the void. Therefore, the goal of our <strong>Baluster Calculator</strong> is not just aesthetic - it saves lives.",
     },
     {
       type: 'title',
@@ -212,7 +212,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
       type: 'card',
       icon: 'mdi:help-circle-outline',
       title: 'What if the last gap does not fit?',
-      html: "<p>If you've used our calculator, this shouldn't happen. However, in the real world, wood warps and posts aren't always straight. If at the end you're off by 1-2 mm, it's imperceptible. If you're off by 1 cm, check your spacer blocks — you've probably been losing mm at each step.</p>",
+      html: "<p>If you've used our calculator, this shouldn't happen. However, in the real world, wood warps and posts aren't always straight. If at the end you're off by 1-2 mm, it's imperceptible. If you're off by 1 cm, check your spacer blocks - you've probably been losing mm at each step.</p>",
     },
     {
       type: 'card',
@@ -224,7 +224,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
       type: 'card',
       icon: 'mdi:wrench-outline',
       title: 'Wood, Metal or Glass?',
-      html: '<p>This calculator works for <strong>any repetitive vertical element</strong>. If you use horizontal steel cables, different regulations apply (they typically must not allow climbing, "ladder effect"). For glass, it is considered a continuous panel and spacing does not apply — impact resistance does.</p>',
+      html: '<p>This calculator works for <strong>any repetitive vertical element</strong>. If you use horizontal steel cables, different regulations apply (they typically must not allow climbing, "ladder effect"). For glass, it is considered a continuous panel and spacing does not apply - impact resistance does.</p>',
     },
     {
       type: 'card',

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

@@ -1,4 +1,4 @@
-import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
 import type { ToolLocaleContent } from '../../../types';
 import type { BalusterCalculatorUI } from '../ui';
 import { bibliography } from '../bibliography';
@@ -15,7 +15,7 @@ const faqData = [
       'En España (CTE) y en la mayoría de normativas internacionales, el espacio libre entre elementos de una barandilla no debe permitir el paso de una esfera de 10 cm de diámetro para evitar accidentes infantiles.',
   },
   {
-    question: '¿Cómo se mide el espaciado: entre centros o huecos?',
+    question: '¿Cómo se mide el espaciado: ¿entre centros o huecos?',
     answer:
       "Nuestra calculadora proporciona ambos. El 'espaciado libre' es el hueco real entre barrotes (vital por seguridad), mientras que la 'distancia entre centros' (on-center) es la que marca dónde taladrar o fijar cada balustre.",
   },

package/src/tool/balusterCalculator/i18n/fr.ts

@@ -1,4 +1,4 @@
-import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
 import type { ToolLocaleContent } from '../../../types';
 import type { BalusterCalculatorUI } from '../ui';
 import { bibliography } from '../bibliography';
@@ -120,7 +120,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
     },
     {
       type: 'paragraph',
-      html: "Cette mesure n'est pas arbitraire. C'est le diamètre moyen de la tête d'un jeune enfant (généralement de moins d'1 an). Si un enfant peut passer son corps mais que sa tête se coince, le risque d'asphyxie est extrêmement élevé. L'objectif de notre <strong>Calculateur de Balustres</strong> n'est donc pas seulement esthétique — il sauve des vies.",
+      html: "Cette mesure n'est pas arbitraire. C'est le diamètre moyen de la tête d'un jeune enfant (généralement de moins d'1 an). Si un enfant peut passer son corps mais que sa tête se coince, le risque d'asphyxie est extrêmement élevé. L'objectif de notre <strong>Calculateur de Balustres</strong> n'est donc pas seulement esthétique - il sauve des vies.",
     },
     {
       type: 'title',
@@ -224,7 +224,7 @@ export const content: ToolLocaleContent<BalusterCalculatorUI> = {
       type: 'card',
       icon: 'mdi:wrench-outline',
       title: 'Bois, Métal ou Verre?',
-      html: '<p>Ce calculateur fonctionne pour <strong>tout élément vertical répétitif</strong>. Pour les câbles en acier horizontaux, une réglementation différente s\'applique. Pour le verre, c\'est un panneau continu et l\'espacement ne s\'applique pas — c\'est la résistance aux chocs qui compte.</p>',
+      html: '<p>Ce calculateur fonctionne pour <strong>tout élément vertical répétitif</strong>. Pour les câbles en acier horizontaux, une réglementation différente s\'applique. Pour le verre, c\'est un panneau continu et l\'espacement ne s\'applique pas - c\'est la résistance aux chocs qui compte.</p>',
     },
     {
       type: 'card',