@jjlmoya/utils-games-development 1.66.0 → 1.68.0

package/src/tests/script_density.test.ts

@@ -1,94 +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 unknown 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);
-        });
-      });
-    });
-  });
-});
+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 unknown 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/seo_length.test.ts

@@ -1,23 +1,23 @@
-import { describe, it, expect } from 'vitest';
-import * as DATA from '../data';
-
-const ENTRIES = [
-  { id: 'gamesCategory', i18n: DATA.gamesCategory.i18n },
-];
-
-describe('SEO Content Length Validation', () => {
-  ENTRIES.forEach((entry) => {
-    describe(`Tool: ${entry.id}`, () => {
-      Object.keys(entry.i18n).forEach((locale) => {
-        it(`${locale}: SEO section should exist`, async () => {
-          const loader = (entry.i18n as Record<string, () => Promise<{ seo?: unknown[] }>>)[locale];
-          if (!loader) return;
-          const content = await loader();
-          if (!content.seo) return;
-          expect(Array.isArray(content.seo)).toBe(true);
-        });
-      });
-    });
-  });
-});
-
+import { describe, it, expect } from 'vitest';
+import * as DATA from '../data';
+
+const ENTRIES = [
+  { id: 'gamesCategory', i18n: DATA.gamesCategory.i18n },
+];
+
+describe('SEO Content Length Validation', () => {
+  ENTRIES.forEach((entry) => {
+    describe(`Tool: ${entry.id}`, () => {
+      Object.keys(entry.i18n).forEach((locale) => {
+        it(`${locale}: SEO section should exist`, async () => {
+          const loader = (entry.i18n as Record<string, () => Promise<{ seo?: unknown[] }>>)[locale];
+          if (!loader) return;
+          const content = await loader();
+          if (!content.seo) return;
+          expect(Array.isArray(content.seo)).toBe(true);
+        });
+      });
+    });
+  });
+});
+

package/src/tests/seo_translation_completeness.test.ts

@@ -28,23 +28,21 @@ 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 {
+function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): string | null {
   const isAsian = ASIAN_LOCALES.includes(locale);
-  const minLength = Math.floor(enLen * (isAsian ? 0.25 : 0.70));
+  const minLength = isAsian ? 120 : Math.max(240, Math.floor(enLen * 0.35));
   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);
+  if (localeLen >= minLength) return null;
+  return `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`;
 }
 
-async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<void> {
-  if (locale === 'en' || !loader) return;
+async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<string | null> {
+  if (locale === 'en' || !loader) return null;
   const content = await loader();
-  if (!content.seo || !Array.isArray(content.seo)) return;
+  if (!content.seo || !Array.isArray(content.seo)) return null;
 
-  checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+  return checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
 }
 
 describe('SEO Translation Completeness & Laziness Audit', () => {
@@ -58,12 +56,20 @@ describe('SEO Translation Completeness & Laziness Audit', () => {
         if (!enContent.seo || !Array.isArray(enContent.seo)) return;
 
         const enSeoLength = calculateSeoTextLength(enContent.seo);
+        const failures: string[] = [];
 
         for (const [locale, loader] of Object.entries(entry.i18n)) {
-          await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+          const failure = await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+          if (failure) failures.push(failure);
         }
+
+        expect(
+          failures,
+          failures.length > 0
+            ? `SEO translation completeness failures for "${entry.id}":\n${failures.map((failure, index) => `${index + 1}. ${failure}`).join('\n')}`
+            : undefined,
+        ).toEqual([]);
       });
     });
   });
 });
-

package/src/tests/slug_language_code_format.test.ts

@@ -1,23 +1,23 @@
-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}$/);
+        }
+      });
+    });
+  });
+});

package/src/tests/slug_uniqueness.test.ts

@@ -1,81 +1,81 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-import type { ToolLocaleContent } from '../types';
-
-const sharingLocales = ['ja', 'ko', 'zh'];
-
-interface ValidateParams {
-  toolId: string;
-  locale: string;
-  content: ToolLocaleContent;
-  enSlug: string;
-  slugs: Map<string, string>;
-}
-
-const validateLocaleSlug = ({
-  toolId,
-  locale,
-  content,
-  enSlug,
-  slugs,
-}: ValidateParams) => {
-  expect(
-    content.slug,
-    `Tool "${toolId}" locale "${locale}" has an invalid slug ("${content.slug}"). Slugs must be transliterated (only a-z, 0-9, and -).`,
-  ).toMatch(/^[a-z0-9-]+$/);
-
-  if (locale === 'en') {
-    return;
-  }
-
-  if (sharingLocales.includes(locale)) {
-    expect(
-      content.slug,
-      `Tool "${toolId}" locale "${locale}" must use the same slug as "en" ("${enSlug}").`,
-    ).toBe(enSlug);
-  } else {
-    expect(
-      content.slug,
-      `Tool "${toolId}" locale "${locale}" has the same slug as "en" ("${enSlug}"). Cada slug tiene que estar en su propia idioma`,
-    ).not.toBe(enSlug);
-
-    if (slugs.has(content.slug)) {
-      const previousLocale = slugs.get(content.slug);
-      expect(
-        false,
-        `Tool "${toolId}" locales "${locale}" and "${previousLocale}" share the same slug ("${content.slug}"). Cada slug tiene que estar en su propia idioma`,
-      ).toBe(true);
-    }
-    slugs.set(content.slug, locale);
-  }
-};
-
-describe('Slug Localization and Uniqueness Validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      it('every locale should have a unique, translated slug', async () => {
-        const slugs = new Map<string, string>();
-        const locales = Object.keys(tool.entry.i18n);
-
-        let enSlug = '';
-        if (locales.includes('en')) {
-          const enLoader = tool.entry.i18n['en' as keyof typeof tool.entry.i18n];
-          const enContent = (await enLoader?.()) as ToolLocaleContent;
-          enSlug = enContent.slug;
-        }
-
-        for (const locale of locales) {
-          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-          const content = (await loader?.()) as ToolLocaleContent;
-          validateLocaleSlug({
-            toolId: tool.entry.id,
-            locale,
-            content,
-            enSlug,
-            slugs,
-          });
-        }
-      });
-    });
-  });
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+const sharingLocales = ['ja', 'ko', 'zh'];
+
+interface ValidateParams {
+  toolId: string;
+  locale: string;
+  content: ToolLocaleContent;
+  enSlug: string;
+  slugs: Map<string, string>;
+}
+
+const validateLocaleSlug = ({
+  toolId,
+  locale,
+  content,
+  enSlug,
+  slugs,
+}: ValidateParams) => {
+  expect(
+    content.slug,
+    `Tool "${toolId}" locale "${locale}" has an invalid slug ("${content.slug}"). Slugs must be transliterated (only a-z, 0-9, and -).`,
+  ).toMatch(/^[a-z0-9-]+$/);
+
+  if (locale === 'en') {
+    return;
+  }
+
+  if (sharingLocales.includes(locale)) {
+    expect(
+      content.slug,
+      `Tool "${toolId}" locale "${locale}" must use the same slug as "en" ("${enSlug}").`,
+    ).toBe(enSlug);
+  } else {
+    expect(
+      content.slug,
+      `Tool "${toolId}" locale "${locale}" has the same slug as "en" ("${enSlug}"). Cada slug tiene que estar en su propia idioma`,
+    ).not.toBe(enSlug);
+
+    if (slugs.has(content.slug)) {
+      const previousLocale = slugs.get(content.slug);
+      expect(
+        false,
+        `Tool "${toolId}" locales "${locale}" and "${previousLocale}" share the same slug ("${content.slug}"). Cada slug tiene que estar en su propia idioma`,
+      ).toBe(true);
+    }
+    slugs.set(content.slug, locale);
+  }
+};
+
+describe('Slug Localization and Uniqueness Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      it('every locale should have a unique, translated slug', async () => {
+        const slugs = new Map<string, string>();
+        const locales = Object.keys(tool.entry.i18n);
+
+        let enSlug = '';
+        if (locales.includes('en')) {
+          const enLoader = tool.entry.i18n['en' as keyof typeof tool.entry.i18n];
+          const enContent = (await enLoader?.()) as ToolLocaleContent;
+          enSlug = enContent.slug;
+        }
+
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          const content = (await loader?.()) as ToolLocaleContent;
+          validateLocaleSlug({
+            toolId: tool.entry.id,
+            locale,
+            content,
+            enSlug,
+            slugs,
+          });
+        }
+      });
+    });
+  });
 });

package/src/tests/title_quality.test.ts

@@ -1,56 +1,56 @@
-import { describe, it } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-
-function getFiles(dir: string, ext: 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()) {
-      results.push(...getFiles(fullPath, ext));
-    } else if (ext.some((e) => file.endsWith(e))) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-const SRC_DIR = path.join(process.cwd(), 'src');
-
-describe('Project Titles - Separator Validation', () => {
-  const files = [
-    ...getFiles(path.join(SRC_DIR, 'tool'), ['.ts']),
-    ...getFiles(path.join(SRC_DIR, 'category'), ['.ts']),
-  ].filter(f => f.includes('i18n'));
-
-  it.each(files)('Verify that titles in %s do not contain | or -', (filePath) => {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const relativePath = path.relative(process.cwd(), filePath);
-
-    const titlePatterns = [
-      /const\s+title\s*=\s*['"]([^'"]+)['"]/g,
-      /title\s*:\s*['"]([^'"]+)['"]/g,
-    ];
-
-    const findings: string[] = [];
-
-    for (const pattern of titlePatterns) {
-      let match;
-      while ((match = pattern.exec(content)) !== null) {
-        const title = match[1];
-        if (!title) continue;
-        if (title.includes('|') || title.includes('-')) {
-          findings.push(title);
-        }
-      }
-    }
-
-    if (findings.length > 0) {
-      const list = findings.map((f) => `  - "${f}"`).join('\n');
-      throw new Error(`Forbidden separators (| or -) found in titles in ${relativePath}:\n${list}`);
-    }
-  });
-});
+import { describe, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getFiles(dir: string, ext: 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()) {
+      results.push(...getFiles(fullPath, ext));
+    } else if (ext.some((e) => file.endsWith(e))) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+const SRC_DIR = path.join(process.cwd(), 'src');
+
+describe('Project Titles - Separator Validation', () => {
+  const files = [
+    ...getFiles(path.join(SRC_DIR, 'tool'), ['.ts']),
+    ...getFiles(path.join(SRC_DIR, 'category'), ['.ts']),
+  ].filter(f => f.includes('i18n'));
+
+  it.each(files)('Verify that titles in %s do not contain | or -', (filePath) => {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const relativePath = path.relative(process.cwd(), filePath);
+
+    const titlePatterns = [
+      /const\s+title\s*=\s*['"]([^'"]+)['"]/g,
+      /title\s*:\s*['"]([^'"]+)['"]/g,
+    ];
+
+    const findings: string[] = [];
+
+    for (const pattern of titlePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const title = match[1];
+        if (!title) continue;
+        if (title.includes('|') || title.includes('-')) {
+          findings.push(title);
+        }
+      }
+    }
+
+    if (findings.length > 0) {
+      const list = findings.map((f) => `  - "${f}"`).join('\n');
+      throw new Error(`Forbidden separators (| or -) found in titles in ${relativePath}:\n${list}`);
+    }
+  });
+});