@jjlmoya/utils-converters 1.15.0 → 1.18.0

package/package.json

@@ -1,16 +1,19 @@
 {
     "name": "@jjlmoya/utils-converters",
-    "version": "1.15.0",
+    "version": "1.18.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
     "exports": {
         ".": "./src/index.ts",
         "./data": "./src/data.ts",
-        "./entries": "./src/entries.ts"
+        "./entries": "./src/entries.ts",
+        "./runtime/*": "./src/tool/*/index.ts",
+        "./category-seo": "./src/category/seo.astro"
     },
     "files": [
-        "src"
+        "src",
+        "scripts"
     ],
     "publishConfig": {
         "access": "public"
@@ -29,7 +32,8 @@
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",
         "minor": "npm version minor",
-        "major": "npm version major"
+        "major": "npm version major",
+        "postinstall": "node scripts/postinstall.mjs"
     },
     "lint-staged": {
         "*.{ts,tsx,astro}": [

package/scripts/clean_titles.py

@@ -0,0 +1,95 @@
+import os
+import re
+
+class FileDiscovery:
+    def __init__(self, root_path, extension):
+        self.root_path = root_path
+        self.extension = extension
+
+    def get_files(self):
+        matched_files = []
+        for root, _, files in os.walk(self.root_path):
+            for file in files:
+                if file.endswith(self.extension):
+                    matched_files.append(os.path.join(root, file))
+        return matched_files
+
+class ContentProcessor:
+    def __init__(self, separators):
+        self.separators = separators
+        self.target_keys = ["title", "text", "name", "faqTitle", "bibliographyTitle"]
+
+    def _clean_text(self, text):
+        cleaned = text
+        for sep in self.separators:
+            if sep in cleaned:
+                cleaned = cleaned.split(sep)[0].strip()
+        return cleaned
+
+    def _replace_callback(self, match):
+        key = match.group(1)
+        quote = match.group(2)
+        text = match.group(3)
+        
+        cleaned_text = self._clean_text(text)
+        return f"{key}: {quote}{cleaned_text}{quote}"
+
+    def _replace_const_callback(self, match):
+        prefix = match.group(1)
+        quote = match.group(2)
+        text = match.group(3)
+        
+        cleaned_text = self._clean_text(text)
+        return f"{prefix}{quote}{cleaned_text}{quote}"
+
+    def _replace_seo_callback(self, match):
+        prefix = match.group(1)
+        quote = match.group(2)
+        text = match.group(3)
+        
+        cleaned_text = self._clean_text(text)
+        return f"{prefix}{quote}{cleaned_text}{quote}"
+
+    def process(self, content):
+        title_keys = ["title", "faqTitle", "bibliographyTitle"]
+        keys_pattern = "|".join(title_keys)
+        
+        pattern = rf"(?<!slug)(?<!\w)({keys_pattern})\s*:\s*(['\"`])(.*?)\2"
+        content = re.sub(pattern, self._replace_callback, content)
+        
+        const_pattern = r"(const\s+title\s*=\s*)(['\"`])(.*?)\2"
+        content = re.sub(const_pattern, self._replace_const_callback, content)
+        
+        seo_pattern = r"(type:\s*['\"]title['\"]\s*,\s*text:\s*)(['\"`])(.*?)\2"
+        content = re.sub(seo_pattern, self._replace_seo_callback, content)
+        
+        return content
+
+class FileStorage:
+    @staticmethod
+    def read(file_path):
+        with open(file_path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    @staticmethod
+    def write(file_path, content):
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+class TitleCleaner:
+    def __init__(self):
+        self.discovery = FileDiscovery("src/tool", ".ts")
+        self.processor = ContentProcessor(["|", "-"])
+        self.storage = FileStorage()
+
+    def run(self):
+        files = self.discovery.get_files()
+        for file_path in files:
+            content = self.storage.read(file_path)
+            new_content = self.processor.process(content)
+            if content != new_content:
+                self.storage.write(file_path, new_content)
+
+if __name__ == "__main__":
+    cleaner = TitleCleaner()
+    cleaner.run()

package/scripts/postinstall.mjs

@@ -0,0 +1,27 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const libDir = dirname(fileURLToPath(import.meta.url));
+const toolsDir = join(libDir, '../src/tool');
+
+const inNodeModules = libDir.includes('node_modules');
+if (!inNodeModules) process.exit(0);
+
+const projectRoot = join(libDir, '../../../..');
+const categoryKey = JSON.parse(readFileSync(join(libDir, '../package.json'), 'utf8')).name.replace('@jjlmoya/utils-', '');
+const destDir = join(projectRoot, `public/styles/lib/${categoryKey}`);
+
+mkdirSync(destDir, { recursive: true });
+
+const tools = readdirSync(toolsDir, { withFileTypes: true }).filter(d => d.isDirectory());
+for (const tool of tools) {
+    const toolDir = join(toolsDir, tool.name);
+    let files;
+    try { files = readdirSync(toolDir).filter(f => f.endsWith('.css')); }
+    catch { continue; }
+    for (const file of files) {
+        writeFileSync(join(destDir, file), readFileSync(join(toolDir, file)));
+        console.log(`[@jjlmoya/utils-${categoryKey}] copied ${file}`);
+    }
+}

package/src/category/i18n/de.ts

@@ -22,7 +22,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Die Wahl des richtigen Bildformats hat direkten Einfluss auf die Web-Performance, die Gerätekompatibilität und die wahrgenommene visuelle Qualität. Unsere <strong>Online-Bild-Konverter</strong> decken die von Designern, Webentwicklern und Fotografen am häufigsten benötigten Konvertierungswege ab – ganz ohne externe Server, die die Vertraulichkeit Ihrer Dateien gefährden könnten.',
+      html: 'Die Wahl des richtigen Bildformats hat direkten Einfluss auf die Web-Performance, die Gerätekompatibilität und die wahrgenommene visuelle Qualität. Unsere <strong>Online-Bild-Konverter</strong> decken die von Designern, Webentwicklern und Fotografen am häufigsten benötigten Konvertierungswege ab - ganz ohne externe Server, die die Vertraulichkeit Ihrer Dateien gefährden könnten.',
     },
     {
       type: 'title',

package/src/category/i18n/fr.ts

@@ -9,15 +9,15 @@ export const content: CategoryLocaleContent = {
       type: 'summary',
       title: 'Pourquoi utiliser nos convertisseurs',
       items: [
-        'Conversion 100% locale : vos images ne quittent jamais votre appareil.',
-        'Support de 21 combinaisons de formats : PNG, JPG, WebP, SVG, AVIF, GIF, BMP et ICO.',
+        'Conversion 100% locale: vos images ne quittent jamais votre appareil.',
+        'Support de 21 combinaisons de formats: PNG, JPG, WebP, SVG, AVIF, GIF, BMP et ICO.',
         'Traitement par lots avec téléchargement ZIP.',
         'Sans inscription, sans limites, sans publicité intrusive.',
       ],
     },
     {
       type: 'title',
-      text: 'Conversion d\'Images : Guide Complet des Formats',
+      text: 'Conversion d\'Images: Guide Complet des Formats',
       level: 2,
     },
     {
@@ -26,12 +26,12 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'PNG, JPG et WebP : Les Trois Piliers du Web Moderne',
+      text: 'PNG, JPG et WebP: Les Trois Piliers du Web Moderne',
       level: 2,
     },
     {
       type: 'paragraph',
-      html: 'Le <strong>format PNG</strong> se distingue par sa compression sans perte et son support de la transparence (canal alpha), étant le standard pour les logos, icônes et graphiques aux bords nets. Le <strong>format JPG</strong> offre une compatibilité universelle maximale et des tailles réduites pour les photos, mais sacrifie la qualité à chaque sauvegarde. Le <strong>format WebP</strong>, développé par Google, combine le meilleur des deux : une compression 30-40% supérieure à PNG/JPG avec support de la transparence et des animations.',
+      html: 'Le <strong>format PNG</strong> se distingue par sa compression sans perte et son support de la transparence (canal alpha), étant le standard pour les logos, icônes et graphiques aux bords nets. Le <strong>format JPG</strong> offre une compatibilité universelle maximale et des tailles réduites pour les photos, mais sacrifie la qualité à chaque sauvegarde. Le <strong>format WebP</strong>, développé par Google, combine le meilleur des deux: une compression 30-40% supérieure à PNG/JPG avec support de la transparence et des animations.',
     },
     {
       type: 'table',
@@ -47,7 +47,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Formats Nouvelle Génération : AVIF et WebP',
+      text: 'Formats Nouvelle Génération: AVIF et WebP',
       level: 2,
     },
     {
@@ -61,7 +61,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'SVG, BMP et ICO : Cas d\'Usage Spéciaux',
+      text: 'SVG, BMP et ICO: Cas d\'Usage Spéciaux',
       level: 2,
     },
     {
@@ -79,12 +79,12 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'title',
-      text: 'Confidentialité Totale : Conversion sans Serveurs',
+      text: 'Confidentialité Totale: Conversion sans Serveurs',
       level: 2,
     },
     {
       type: 'paragraph',
-      html: 'Contrairement à d\'autres outils en ligne qui téléchargent vos images sur des serveurs distants, nos convertisseurs utilisent exclusivement les APIs natives du navigateur : <strong>Canvas 2D API</strong> pour la rastérisation, <strong>FileReader API</strong> pour lire les fichiers localement et <strong>Blob/URL.createObjectURL</strong> pour les téléchargements. Vous pouvez ainsi convertir des images confidentielles, des logos d\'entreprise ou des documents privés en toute sécurité.',
+      html: 'Contrairement à d\'autres outils en ligne qui téléchargent vos images sur des serveurs distants, nos convertisseurs utilisent exclusivement les APIs natives du navigateur: <strong>Canvas 2D API</strong> pour la rastérisation, <strong>FileReader API</strong> pour lire les fichiers localement et <strong>Blob/URL.createObjectURL</strong> pour les téléchargements. Vous pouvez ainsi convertir des images confidentielles, des logos d\'entreprise ou des documents privés en toute sécurité.',
     },
   ],
 };

package/src/category/i18n/ru.ts

@@ -66,7 +66,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: '<strong>Файлы SVG</strong> — это математические векторы, которые масштабируются без потерь до любого разрешения, что идеально подходит для логотипов и графического дизайна. Однако многие платформы и приложения для редактирования не поддерживают их напрямую, поэтому для распространения их необходимо растрировать в PNG или JPG. <strong>Битмап-файлы (BMP)</strong>, хотя и устарели для использования в Интернете, по-прежнему часто встречаются в среде Windows и устаревшем программном обеспечении для редактирования. Наконец, <strong>формат ICO</strong> является стандартом для веб-фавиконов и настройки значков Windows, требуя определенной структуры двоичного заголовка, которую наш конвертер генерирует нативно.',
+      html: '<strong>Файлы SVG</strong> - это математические векторы, которые масштабируются без потерь до любого разрешения, что идеально подходит для логотипов и графического дизайна. Однако многие платформы и приложения для редактирования не поддерживают их напрямую, поэтому для распространения их необходимо растрировать в PNG или JPG. <strong>Битмап-файлы (BMP)</strong>, хотя и устарели для использования в Интернете, по-прежнему часто встречаются в среде Windows и устаревшем программном обеспечении для редактирования. Наконец, <strong>формат ICO</strong> является стандартом для веб-фавиконов и настройки значков Windows, требуя определенной структуры двоичного заголовка, которую наш конвертер генерирует нативно.',
     },
     {
       type: 'stats',

package/src/category/i18n/sv.ts

@@ -31,7 +31,7 @@ export const content: CategoryLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: '<strong>PNG-formatet</strong> utmärker sig för sin förlustfria komprimering och stöd för transparens (alfakanal), och är standarden för logotyper, ikoner och grafik med skarpa kanter. <strong>JPG-formatet</strong> erbjuder maximal universell kompatibilitet och reducerade storlekar för foton, men offrar kvalitet vid varje sparande. <strong>WebP-formatet</strong>, utvecklat av Google, kombinerar det bästa av båda: 30–40 % bättre komprimering än PNG/JPG med stöd för transparens och animering, och är nu det rekommenderade formatet av Core Web Vitals för att förbättra LCP.',
+      html: '<strong>PNG-formatet</strong> utmärker sig för sin förlustfria komprimering och stöd för transparens (alfakanal), och är standarden för logotyper, ikoner och grafik med skarpa kanter. <strong>JPG-formatet</strong> erbjuder maximal universell kompatibilitet och reducerade storlekar för foton, men offrar kvalitet vid varje sparande. <strong>WebP-formatet</strong>, utvecklat av Google, kombinerar det bästa av båda: 30-40 % bättre komprimering än PNG/JPG med stöd för transparens och animering, och är nu det rekommenderade formatet av Core Web Vitals för att förbättra LCP.',
     },
     {
       type: 'table',

package/src/data.ts

@@ -1,24 +1,3 @@
-export { pngAJpg } from './tool/pngAJpg';
-export { jpgAPng } from './tool/jpgAPng';
-export { webpAPng } from './tool/webpAPng';
-export { webpAJpg } from './tool/webpAJpg';
-export { pngAWebp } from './tool/pngAWebp';
-export { jpgAWebp } from './tool/jpgAWebp';
-export { svgAPng } from './tool/svgAPng';
-export { svgAJpg } from './tool/svgAJpg';
-export { imagenBase64 } from './tool/imagenBase64';
-export { bmpAJpg } from './tool/bmpAJpg';
-export { bmpAPng } from './tool/bmpAPng';
-export { bmpAWebp } from './tool/bmpAWebp';
-export { avifAJpg } from './tool/avifAJpg';
-export { avifAPng } from './tool/avifAPng';
-export { avifAWebp } from './tool/avifAWebp';
-export { gifAJpg } from './tool/gifAJpg';
-export { gifAPng } from './tool/gifAPng';
-export { gifAWebp } from './tool/gifAWebp';
-export { pngAIco } from './tool/pngAIco';
-export { jpgAIco } from './tool/jpgAIco';
-export { webpAIco } from './tool/webpAIco';
 export { convertersCategory } from './category';
 
 export type { ImageConverterUI } from './shared/ImageConverter.astro';

package/src/layouts/PreviewLayout.astro

@@ -1,4 +1,4 @@
----
+---
 import "@jjlmoya/utils-shared/theme.css";
 import PreviewToolbar from "../components/PreviewToolbar.astro";
 import type { KnownLocale } from "../types";
@@ -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/pages/[locale]/[slug].astro

@@ -34,18 +34,28 @@ export async function getStaticPaths() {
       ]),
     ) as Partial<Record<KnownLocale, string>>;
 
+    const firstLoader = entry.i18n.en ?? Object.values(entry.i18n)[0];
+    const englishSlug = firstLoader ? (await firstLoader()).slug : entry.id;
+
     for (const { locale, content } of localeContents) {
-      const allToolsNav = await Promise.all(
-        ALL_TOOLS.map(async ({ entry: navEntry }) => ({
-          id: navEntry.id,
-          title: (await navEntry.i18n[locale]!()).title,
-          href: `/${locale}/${(await navEntry.i18n[locale]!()).slug}`,
-          isActive: navEntry.id === entry.id,
-        })),
-      );
+      const allToolsNav = (
+        await Promise.all(
+          ALL_TOOLS.map(async ({ entry: navEntry }) => {
+            const loader = navEntry.i18n[locale] ?? navEntry.i18n.en;
+            if (!loader) return null;
+            const navContent = await loader();
+            return {
+              id: navEntry.id,
+              title: navContent.title,
+              href: `/${locale}/${navContent.slug}`,
+              isActive: navEntry.id === entry.id,
+            };
+          }),
+        )
+      ).filter(Boolean) as NavItem[];
       paths.push({
         params: { locale, slug: content.slug },
-        props: { Component, locale, content, localeUrls, allToolsNav },
+        props: { Component, locale, content, localeUrls, allToolsNav, englishSlug },
       });
     }
   }
@@ -66,11 +76,16 @@ interface Props {
   content: ToolLocaleContent;
   localeUrls: Partial<Record<KnownLocale, string>>;
   allToolsNav: NavItem[];
+  englishSlug: string;
 }
 
-const { Component, locale, content, localeUrls, allToolsNav } = Astro.props;
+const { Component, locale, content, localeUrls, allToolsNav, englishSlug } = Astro.props;
+
+const cssFiles = import.meta.glob("../../tool/**/*.css", { query: "?raw", import: "default" });
+const cssKey = Object.keys(cssFiles).find((k) => k.endsWith(`/${englishSlug}.css`));
+const toolCss = cssKey ? await cssFiles[cssKey]() as string : "";
 
-const seoContent: UtilitySEOContent = { locale, sections: content.seo };
+const seoContent: UtilitySEOContent = { locale, sections: content.seo ?? [] };
 
 const words = content.title.split(" ");
 const titleHighlight = words[0] || "";
@@ -89,8 +104,9 @@ const titleBase = words.slice(1).join(" ") || "";
     tools={allToolsNav}
   />
   <Fragment slot="head">
+    {toolCss ? <Fragment set:html={`<style is:inline>${toolCss}</style>`} /> : null}
     {
-      content.schemas.map((schema) => (
+      ( content.schemas ?? []).map((schema) => (
         <script
           is:inline
           type="application/ld+json"

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/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('--');
+    });
+  });
+});