@jjlmoya/utils-textiles 1.22.0 → 1.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-textiles",
-    "version": "1.22.0",
+    "version": "1.24.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -27,7 +27,7 @@
         "lint": "eslint src/ --max-warnings 0 && stylelint \"src/**/*.{css,astro}\"",
         "check": "astro check",
         "type-check": "astro check",
-        "test": "vitest run",
+        "test": "vitest run --reporter=verbose --testTimeout=30000",
         "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",

package/src/tests/bibliography_wellformed_export.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+function findBibliographyAstroFiles(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(...findBibliographyAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name === 'bibliography.astro') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const toolDir = join(process.cwd(), 'src', 'tool');
+const bibliographyFiles = findBibliographyAstroFiles(toolDir);
+
+describe('Bibliography Component Wellformed Export', () => {
+  it('found tool bibliography.astro components', () => {
+    expect(bibliographyFiles.length).toBeGreaterThan(0);
+  });
+
+  bibliographyFiles.forEach((file) => {
+    const relativePath = relative(process.cwd(), file);
+
+    it(`${relativePath} should use SharedBibliography from @jjlmoya/utils-shared`, () => {
+      const content = readFileSync(file, 'utf-8');
+
+      const usesSharedComponent =
+        content.includes('@jjlmoya/utils-shared') &&
+        (content.includes('Bibliography') || content.includes('SharedBibliography'));
+
+      expect(
+        usesSharedComponent,
+        `File "${relativePath}" does not use the standard Bibliography component from @jjlmoya/utils-shared, resulting in unstyled or raw bibliography output.`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/category_seo_quality.test.ts

@@ -0,0 +1,74 @@
+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');
+  check(content.seo.some((section) => section.type === 'paragraph'), 'SEO needs visible explanatory copy');
+
+  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) : [];
+    });
+
+    for (const locale of EXPECTED_LOCALES) {
+      const content = contents.get(locale);
+      if (!content) failures.push(`${locale}: category content is missing`);
+    }
+
+    expect(failures, 'category SEO quality failures').toEqual([]);
+  }, 30000);
+});

package/src/tests/seo_parity.test.ts

@@ -27,7 +27,7 @@ async function verifyLocaleParity(
   expect(
     locSeoCount,
     `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
-  ).toBe(expected.seo);
+  ).toBeGreaterThanOrEqual(expected.seo);
   expect(
     locFaqCount,
     `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,
@@ -41,7 +41,7 @@ async function verifyLocaleParity(
 describe('SEO & i18n Structural Parity Suite', () => {
   ALL_ENTRIES.forEach((entry) => {
     describe(`Tool: ${entry.id}`, () => {
-      it('all 15 locales should have identical SEO section counts and types as English', async () => {
+      it('all 15 locales should provide at least the complete English SEO section set', async () => {
         const enContent = await entry.i18n.en?.();
         expect(enContent).toBeDefined();
         const expected: ExpectedCounts = {

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