@jjlmoya/utils-developer 1.30.0 → 1.32.0

package/src/tests/category_seo_quality.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import type { CategoryLocaleContent } from '../types';
+
+const EXPECTED_LOCALES = [
+  'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh',
+] as const;
+const COMPACT_LOCALES = new Set(['ja', 'ko', 'zh']);
+
+const localeModules = import.meta.glob('../category/i18n/*.ts', { eager: true }) as Record<
+  string,
+  { content: CategoryLocaleContent }
+>;
+
+function textFrom(value: unknown): string {
+  if (typeof value === 'string') return value.replace(/<[^>]*>/g, ' ');
+  if (Array.isArray(value)) return value.map(textFrom).join(' ');
+  if (value && typeof value === 'object') return Object.values(value).map(textFrom).join(' ');
+  return '';
+}
+
+const STRONG_CLAIM = /\b(?:garantiz\w*|guarante\w*|validat(?:ed)|valid(?:ated|ado|ada|ados|adas|ée|ées)|actualizad\w*)\b/iu;
+
+function getContents(): Map<string, CategoryLocaleContent> {
+  return new Map(
+    Object.entries(localeModules).map(([file, module]) => [file.match(/\/([a-z]{2})\.ts$/u)?.[1] ?? file, module.content]),
+  );
+}
+
+function validateContent(locale: string, content: CategoryLocaleContent): string[] {
+  const failures: string[] = [];
+  const check = (condition: boolean, message: string) => { if (!condition) failures.push(`${locale}: ${message}`); };
+  const minimumTitleLength = COMPACT_LOCALES.has(locale) ? 4 : 12;
+  const minimumDescriptionLength = COMPACT_LOCALES.has(locale) ? 20 : 60;
+  check(content.title.trim().length >= minimumTitleLength && content.title.trim().length <= 70, 'title must use a useful 4/12–70 character length');
+  check(content.description.trim().length >= minimumDescriptionLength && content.description.trim().length <= 180, 'description must use a useful 20/60–180 character length');
+  check(content.seo.length >= 2, 'SEO needs at least two sections');
+
+  const seoText = textFrom(content.seo).replace(/\s+/g, ' ').trim();
+  const minimumSeoLength = COMPACT_LOCALES.has(locale) ? 120 : 240;
+  check(seoText.length >= minimumSeoLength, 'SEO copy must contain the minimum visible copy for its script');
+  check(content.seo.filter((section) => section.type === 'title').length >= 1, 'SEO needs a section heading');
+  check(!/[�]/u.test(seoText), 'SEO contains replacement characters');
+  check(!/ {2,}/u.test(seoText), 'SEO contains duplicated whitespace');
+  check(!STRONG_CLAIM.test(seoText), 'SEO contains an unsupported strong claim');
+
+  check(content.slug.trim().length > 0 && /^[a-z0-9-]+$/u.test(content.slug), 'slug must be a non-empty URL-safe value');
+  return failures;
+}
+
+describe('Category SEO quality contract', () => {
+  it('has one content file for every configured locale', () => {
+    const contents = getContents();
+    expect([...contents.keys()].sort()).toEqual([...EXPECTED_LOCALES].sort());
+  });
+
+  it('keeps metadata, SEO structure and copy quality above the minimum in every locale', () => {
+    const contents = getContents();
+    const english = contents.get('en');
+    expect(english, 'English category content is required as the structural reference').toBeDefined();
+
+    const failures = EXPECTED_LOCALES.flatMap((locale) => {
+      const content = contents.get(locale);
+      return content ? validateContent(locale, content) : [];
+    });
+
+    const englishShape = english?.seo.map((section) => section.type);
+    for (const locale of EXPECTED_LOCALES) {
+      const content = contents.get(locale);
+      if (content && JSON.stringify(content.seo.map((section) => section.type)) !== JSON.stringify(englishShape)) {
+        failures.push(`${locale}: SEO section types must match English`);
+      }
+    }
+
+    expect(failures, 'category SEO quality failures').toEqual([]);
+  }, 30000);
+});

package/src/tests/entry_contract.test.ts

@@ -2,9 +2,15 @@ import { describe, expect, it } from 'vitest';
 import { ALL_ENTRIES } from '../entries';
 
 describe('Tool entry consumer contract', () => {
-  it('every published tool exposes a Spanish locale loader', () => {
+  const requiredLocales = [
+    'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh',
+  ];
+
+  it('every published tool exposes all required locale loaders', () => {
     for (const entry of ALL_ENTRIES) {
-      expect(typeof entry.i18n.es, `${entry.id} must expose i18n.es`).toBe('function');
+      for (const locale of requiredLocales) {
+        expect(typeof entry.i18n[locale as keyof typeof entry.i18n], `${entry.id} must expose i18n.${locale}`).toBe('function');
+      }
     }
   });
 });

package/src/tests/faq_count.test.ts

@@ -16,4 +16,4 @@ describe('FAQ Content Validation', () => {
     expect(TOOLS.length).toBe(0);
   });
 });
-
+

package/src/tests/i18n_coverage.test.ts

@@ -4,8 +4,6 @@ import { ALL_TOOLS } from '../tools';
 const EXPECTED_LOCALES = [
   'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh'
 ];
-const ENGLISH_FIRST_TOOLS = new Set(['promote-this-website']);
-
 describe('I18n Coverage Validation', () => {
   it('all tools should be registered', () => {
     expect(ALL_TOOLS.length).toBeGreaterThan(0);
@@ -15,8 +13,7 @@ describe('I18n Coverage Validation', () => {
     describe(`Tool: ${entry.id}`, () => {
       it('should have all 15 required locales', () => {
         const registeredLocales = Object.keys(entry.i18n);
-        const requiredLocales = ENGLISH_FIRST_TOOLS.has(entry.id) ? ['en'] : EXPECTED_LOCALES;
-        requiredLocales.forEach((locale) => {
+        EXPECTED_LOCALES.forEach((locale) => {
           expect(
             registeredLocales,
             `Tool "${entry.id}" is missing locale "${locale}"`,
@@ -25,8 +22,7 @@ describe('I18n Coverage Validation', () => {
       });
 
       it('all locale loaders should be functions', () => {
-        const requiredLocales = ENGLISH_FIRST_TOOLS.has(entry.id) ? ['en'] : EXPECTED_LOCALES;
-        requiredLocales.forEach((locale) => {
+        EXPECTED_LOCALES.forEach((locale) => {
           const loader = entry.i18n[locale as keyof typeof entry.i18n];
           expect(
             typeof loader,

package/src/tests/inverted_punctuation.test.ts

@@ -1,113 +1,113 @@
-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 boundaries = [
-    ...[...beforeMark.matchAll(/\.(?=\s|$)/g)].map((m) => m.index ?? 0),
-    ...[...beforeMark.matchAll(/:(?=\s|$)/g)].map((m) => m.index ?? 0),
-    ...[...beforeMark.matchAll(/;(?=\s|$)/g)].map((m) => m.index ?? 0),
-  ];
-
-  const lastBoundary = boundaries.length > 0
-    ? Math.max(...boundaries)
-    : -1;
-
-  const nlBoundary = beforeMark.lastIndexOf('\n');
-  const boundary = Math.max(lastBoundary, nlBoundary);
-
-  return beforeMark.slice(boundary + 1).trimStart();
-}
-
-function isCodeContext(text: string, index: number, mark: string): boolean {
-  if (mark === '!') {
-    const after = text.slice(index + 1, index + 10);
-    return /^important\b/.test(after);
-  }
-  if (mark === '?') {
-    const before = text.slice(Math.max(0, index - 2), index);
-    return /[,#\/&+=]/.test(before) || / y $/.test(text.slice(0, index));
-  }
-  return false;
-}
-
-function findMissingInvertedMarks(
-  text: string,
-  startMark: string,
-  endMark: string,
-  _toolId: string,
-): string[] {
-  const cleaned = text.replace(/<code>.*?<\/code>/g, '');
-
-  return [...cleaned.matchAll(new RegExp(`\\${endMark}`, 'g'))]
-    .filter((match) => !isCodeContext(cleaned, match.index ?? 0, endMark))
-    .map((match) => sentenceStart(cleaned, match.index ?? 0))
-    .filter((segment) => {
-      if (segment.length === 0) return false;
-      if (segment.includes(startMark)) return false;
-      if (endMark === '?' && /:\/\//.test(segment)) return false;
-      return true;
-    })
-    .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 toolId = tool.entry.id;
-          const missingQuestions = strings.flatMap((text) =>
-            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd, toolId)
-          );
-          const missingExclamations = strings.flatMap((text) =>
-            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd, toolId)
-          );
-          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);
-        });
-      });
-    });
-  });
-});
+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 boundaries = [
+    ...[...beforeMark.matchAll(/\.(?=\s|$)/g)].map((m) => m.index ?? 0),
+    ...[...beforeMark.matchAll(/:(?=\s|$)/g)].map((m) => m.index ?? 0),
+    ...[...beforeMark.matchAll(/;(?=\s|$)/g)].map((m) => m.index ?? 0),
+  ];
+
+  const lastBoundary = boundaries.length > 0
+    ? Math.max(...boundaries)
+    : -1;
+
+  const nlBoundary = beforeMark.lastIndexOf('\n');
+  const boundary = Math.max(lastBoundary, nlBoundary);
+
+  return beforeMark.slice(boundary + 1).trimStart();
+}
+
+function isCodeContext(text: string, index: number, mark: string): boolean {
+  if (mark === '!') {
+    const after = text.slice(index + 1, index + 10);
+    return /^important\b/.test(after);
+  }
+  if (mark === '?') {
+    const before = text.slice(Math.max(0, index - 2), index);
+    return /[,#\/&+=]/.test(before) || / y $/.test(text.slice(0, index));
+  }
+  return false;
+}
+
+function findMissingInvertedMarks(
+  text: string,
+  startMark: string,
+  endMark: string,
+  _toolId: string,
+): string[] {
+  const cleaned = text.replace(/<code>.*?<\/code>/g, '');
+
+  return [...cleaned.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+    .filter((match) => !isCodeContext(cleaned, match.index ?? 0, endMark))
+    .map((match) => sentenceStart(cleaned, match.index ?? 0))
+    .filter((segment) => {
+      if (segment.length === 0) return false;
+      if (segment.includes(startMark)) return false;
+      if (endMark === '?' && /:\/\//.test(segment)) return false;
+      return true;
+    })
+    .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 toolId = tool.entry.id;
+          const missingQuestions = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd, toolId)
+          );
+          const missingExclamations = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd, toolId)
+          );
+          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

@@ -36,6 +36,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all 28 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(29);
+    expect(ALL_TOOLS.length).toBe(30);
   });
 });

package/src/tests/mocks/astro_mock.js

@@ -1,2 +1,2 @@
 export default function () { return null; }
-
+

package/src/tests/no_h1_in_components.test.ts

@@ -45,4 +45,4 @@ describe('No H1 in Components', () => {
     });
   });
 });
-
+

package/src/tests/promote_this_website_i18n.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { promoteThisWebsite } from '../tool/promoteThisWebsite/entry';
+
+const locales = [
+  'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh',
+];
+
+describe('promote-this-website translations', () => {
+  it('provides every visible UI key in every locale', async () => {
+    const english = await promoteThisWebsite.i18n.en!();
+    const expectedKeys = Object.keys(english.ui).sort();
+
+    for (const locale of locales) {
+      const content = await promoteThisWebsite.i18n[locale as keyof typeof promoteThisWebsite.i18n]!();
+      expect(Object.keys(content.ui).sort(), `${locale} has an incomplete UI translation`).toEqual(expectedKeys);
+      expect(content.faq).toHaveLength(english.faq.length);
+      expect(content.howTo).toHaveLength(english.howTo.length);
+      expect(content.seo).toHaveLength(english.seo.length);
+    }
+  });
+
+  it('does not silently use English for the core translated controls', async () => {
+    const english = await promoteThisWebsite.i18n.en!();
+    const translatedControls = ['urlLabel', 'applyUrl', 'titleLabel', 'download', 'reset', 'titleStyleLabel', 'brandStyleLabel'];
+
+    for (const locale of locales.filter((locale) => locale !== 'en')) {
+      const content = await promoteThisWebsite.i18n[locale as keyof typeof promoteThisWebsite.i18n]!();
+      for (const key of translatedControls) {
+        expect(content.ui[key], `${locale}.${key} is still English`).not.toBe(english.ui[key]);
+      }
+    }
+  });
+});

package/src/tests/seo_translation_completeness.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const ASIAN_LOCALES = ['ja', 'ko', 'zh'];
+
+function getSimpleSectionLength(section: any): number {
+  if (section.type === 'title') return section.text ? section.text.length : 0;
+  if (section.type === 'paragraph') return section.html ? section.html.replace(/<[^>]*>/g, '').length : 0;
+  if (section.type === 'list') return section.items ? section.items.join('').length : 0;
+  return 0;
+}
+
+function getComplexSectionLength(section: any): number {
+  if (section.type === 'diagnostic' || section.type === 'tip') {
+    return (section.title ? section.title.length : 0) + (section.html ? section.html.replace(/<[^>]*>/g, '').length : 0);
+  }
+  if (section.type === 'table') {
+    return ((section.headers || []).join('').length) + ((section.rows || []).flat().join('').length);
+  }
+  return 0;
+}
+
+function getSectionLength(section: any): number {
+  return getSimpleSectionLength(section) || getComplexSectionLength(section);
+}
+
+function calculateSeoTextLength(seoSections: any[]): number {
+  return seoSections.reduce((acc, section) => acc + getSectionLength(section), 0);
+}
+
+function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): void {
+  const isAsian = ASIAN_LOCALES.includes(locale);
+  const minLength = Math.floor(enLen * (isAsian ? 0.25 : 0.70));
+  const msgType = isAsian ? 'suspiciously short' : 'truncated/lazy';
+
+  expect(
+    localeLen,
+    `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`,
+  ).toBeGreaterThanOrEqual(minLength);
+}
+
+async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<void> {
+  if (locale === 'en' || !loader) return;
+  const content = await loader();
+  if (!content.seo || !Array.isArray(content.seo)) return;
+
+  checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+}
+
+describe('SEO Translation Completeness & Laziness Audit', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should not have lazy or truncated SEO content compared to English reference', async () => {
+        const enLoader = entry.i18n['en' as keyof typeof entry.i18n];
+        if (!enLoader) return;
+
+        const enContent = await enLoader();
+        if (!enContent.seo || !Array.isArray(enContent.seo)) return;
+
+        const enSeoLength = calculateSeoTextLength(enContent.seo);
+
+        for (const [locale, loader] of Object.entries(entry.i18n)) {
+          await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+        }
+      });
+    });
+  });
+});
+

package/src/tests/seo_wellformed_export.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+function findSeoAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  if (!existsSync(dir)) return files;
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findSeoAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name === 'seo.astro') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const toolDir = join(process.cwd(), 'src', 'tool');
+const seoFiles = findSeoAstroFiles(toolDir);
+
+describe('SEO Component Wellformed Export', () => {
+  it('found tool seo.astro components', () => {
+    expect(seoFiles.length).toBeGreaterThan(0);
+  });
+
+  seoFiles.forEach((file) => {
+    const relativePath = relative(process.cwd(), file);
+
+    it(`${relativePath} should dynamically load SEO sections and use SEORenderer`, () => {
+      const content = readFileSync(file, 'utf-8');
+
+      const usesSeoRenderer =
+        content.includes('@jjlmoya/utils-shared') &&
+        (content.includes('SEORenderer') || content.includes('SEOArticle'));
+
+      const acquiresDynamicContent =
+        content.includes('.i18n') ||
+        content.includes('loader') ||
+        content.includes('await loader') ||
+        content.includes('.seo');
+
+      const isBrokenPattern =
+        /sections\s*=\s*\[\s*\]/.test(content) && !acquiresDynamicContent;
+
+      expect(
+        usesSeoRenderer,
+        `File "${relativePath}" does not import or use SEORenderer from @jjlmoya/utils-shared.`,
+      ).toBe(true);
+
+      expect(
+        isBrokenPattern,
+        `File "${relativePath}" relies on a static sections=[] prop default without fetching content from entry.i18n, resulting in empty SEO text on consumers.`,
+      ).toBe(false);
+
+      expect(
+        acquiresDynamicContent,
+        `File "${relativePath}" does not fetch dynamic i18n content for SEO rendering.`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/slug_language_code_format.test.ts

@@ -1,25 +1,25 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-import type { ToolLocaleContent } from '../types';
-
-describe('Slug Language Code Format Validation', () => {
-
-
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      it('slug should not end with 2-letter language codes like -ja, -ru, -ko', async () => {
-        const locales = Object.keys(tool.entry.i18n);
-
-        for (const locale of locales) {
-          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-          const content = (await loader?.()) as ToolLocaleContent;
-
-          expect(
-            content.slug,
-            `Tool "${tool.entry.id}" locale "${locale}" slug ("${content.slug}") cannot end with a 2-letter language code (e.g., -ja, -ru, -ko).`,
-          ).not.toMatch(/-[a-z]{2}$/);
-        }
-      });
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Slug Language Code Format Validation', () => {
+
+
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      it('slug should not end with 2-letter language codes like -ja, -ru, -ko', async () => {
+        const locales = Object.keys(tool.entry.i18n);
+
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          const content = (await loader?.()) as ToolLocaleContent;
+
+          expect(
+            content.slug,
+            `Tool "${tool.entry.id}" locale "${locale}" slug ("${content.slug}") cannot end with a 2-letter language code (e.g., -ja, -ru, -ko).`,
+          ).not.toMatch(/-[a-z]{2}$/);
+        }
+      });
+    });
+  });
+});