@jjlmoya/utils-games-development 1.66.0 → 1.68.0

package/src/tests/diacritics_density.test.ts

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

@@ -1,19 +1,19 @@
-import { describe, it, expect } from 'vitest';
-import type * as DATA from '../data';
-
-const TOOLS: typeof DATA.gamesCategory[] = [];
-
-describe('FAQ Content Validation', () => {
-  TOOLS.forEach((entry) => {
-    describe(`Tool: ${entry.icon}`, () => {
-      it('placeholder', () => {
-        expect(true).toBe(true);
-      });
-    });
-  });
-
-  it('no tools registered yet', () => {
-    expect(TOOLS.length).toBe(0);
-  });
-});
-
+import { describe, it, expect } from 'vitest';
+import type * as DATA from '../data';
+
+const TOOLS: typeof DATA.gamesCategory[] = [];
+
+describe('FAQ Content Validation', () => {
+  TOOLS.forEach((entry) => {
+    describe(`Tool: ${entry.icon}`, () => {
+      it('placeholder', () => {
+        expect(true).toBe(true);
+      });
+    });
+  });
+
+  it('no tools registered yet', () => {
+    expect(TOOLS.length).toBe(0);
+  });
+});
+

package/src/tests/i18n_coverage.test.ts

@@ -1,36 +1,36 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-
-const EXPECTED_LOCALES = [
-  'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh'
-];
-
-describe('I18n Coverage Validation', () => {
-  it('all tools should be registered', () => {
-    expect(ALL_TOOLS.length).toBeGreaterThan(0);
-  });
-
-  ALL_TOOLS.forEach(({ entry }: { entry: any }) => {
-    describe(`Tool: ${entry.id}`, () => {
-      it('should have all 15 required locales', () => {
-        const registeredLocales = Object.keys(entry.i18n);
-        EXPECTED_LOCALES.forEach((locale) => {
-          expect(
-            registeredLocales,
-            `Tool "${entry.id}" is missing locale "${locale}"`,
-          ).toContain(locale);
-        });
-      });
-
-      it('all locale loaders should be functions', () => {
-        EXPECTED_LOCALES.forEach((locale) => {
-          const loader = entry.i18n[locale as keyof typeof entry.i18n];
-          expect(
-            typeof loader,
-            `Tool "${entry.id}" locale "${locale}" loader is not a function`,
-          ).toBe('function');
-        });
-      });
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const EXPECTED_LOCALES = [
+  'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh'
+];
+
+describe('I18n Coverage Validation', () => {
+  it('all tools should be registered', () => {
+    expect(ALL_TOOLS.length).toBeGreaterThan(0);
+  });
+
+  ALL_TOOLS.forEach(({ entry }: { entry: any }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should have all 15 required locales', () => {
+        const registeredLocales = Object.keys(entry.i18n);
+        EXPECTED_LOCALES.forEach((locale) => {
+          expect(
+            registeredLocales,
+            `Tool "${entry.id}" is missing locale "${locale}"`,
+          ).toContain(locale);
+        });
+      });
+
+      it('all locale loaders should be functions', () => {
+        EXPECTED_LOCALES.forEach((locale) => {
+          const loader = entry.i18n[locale as keyof typeof entry.i18n];
+          expect(
+            typeof loader,
+            `Tool "${entry.id}" locale "${locale}" loader is not a function`,
+          ).toBe('function');
+        });
+      });
+    });
+  });
+});

package/src/tests/inverted_punctuation.test.ts

@@ -1,84 +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 unknown 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);
-        });
-      });
-    });
-  });
-});
+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 unknown 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/mocks/astro_mock.js

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

package/src/tests/no_en_dash.test.ts

@@ -1,70 +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('--');
-    });
-  });
-});
+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('--');
+    });
+  });
+});