@jjlmoya/utils-social 1.16.0 → 1.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-social",
-    "version": "1.16.0",
+    "version": "1.18.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -28,7 +28,7 @@
         "check": "astro check",
         "type-check": "astro check",
         "test": "vitest run",
-        "preversion": "npm run lint && npm run test",
+        "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",
         "minor": "npm version minor",

package/src/tests/seo_parity.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+import type { KnownLocale } from '../types';
+
+interface ExpectedCounts {
+  seo: number;
+  faq: number;
+  howTo: number;
+}
+
+function countItems(arr: unknown[] | undefined): number {
+  return arr?.length ?? 0;
+}
+
+async function verifyLocaleParity(
+  entry: typeof ALL_ENTRIES[number],
+  loc: KnownLocale,
+  expected: ExpectedCounts,
+): Promise<void> {
+  const locContent = await entry.i18n[loc]?.();
+  expect(locContent, `Locale ${loc} missing content`).toBeDefined();
+
+  const locSeoCount = countItems(locContent?.seo);
+  const locFaqCount = countItems(locContent?.faq);
+  const locHowToCount = countItems(locContent?.howTo);
+
+  expect(
+    locSeoCount,
+    `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
+  ).toBe(expected.seo);
+  expect(
+    locFaqCount,
+    `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,
+  ).toBe(expected.faq);
+  expect(
+    locHowToCount,
+    `Locale ${loc} HowTo steps count (${locHowToCount}) must match EN (${expected.howTo})`,
+  ).toBe(expected.howTo);
+}
+
+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 () => {
+        const enContent = await entry.i18n.en?.();
+        expect(enContent).toBeDefined();
+        const expected: ExpectedCounts = {
+          seo: countItems(enContent?.seo),
+          faq: countItems(enContent?.faq),
+          howTo: countItems(enContent?.howTo),
+        };
+
+        const locales = Object.keys(entry.i18n) as KnownLocale[];
+        for (const loc of locales) {
+          await verifyLocaleParity(entry, loc, expected);
+        }
+      });
+    });
+  });
+});

package/src/tests/spanish_leakage.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+
+const STRUCTURAL_KEYS = new Set([
+  'id',
+  'slug',
+  'url',
+  'icon',
+  'image',
+  'imageUrl',
+  'keywords',
+  'category',
+  'tags',
+  'toolId',
+  'type',
+  'locale',
+  'language',
+  'direction',
+]);
+
+const TRANSLATABLE_KEYS = [
+  'title',
+  'description',
+  'faqTitle',
+  'faq',
+  'howTo',
+  'seo',
+  'schemas',
+] as const;
+
+const SPANISH_MARKERS = [
+  ['sangre', /\bsangre\b/gi],
+  ['molino', /\bmolino\b/gi],
+  ['grano', /\bgrano\b/gi],
+  ['paladar', /\bpaladar\b/gi],
+  ['cuchillas', /\bcuchillas\b/gi],
+  ['trozos', /\btrozos\b/gi],
+  ['frescura', /\bfrescura\b/gi],
+  ['ingresa', /\bingresa\b/gi],
+  ['selecciona', /\bselecciona\b/gi],
+  ['herramienta', /\bherramienta\b/gi],
+  ['según', /\bsegún\b/gi],
+  ['después', /\bdespués\b/gi],
+  ['puedes', /\bpuedes\b/gi],
+  ['debes', /\bdebes\b/gi],
+  ['tus', /\btus\b/gi],
+  ['a la vez', /\ba la vez\b/gi],
+  ['los datos', /\blos datos\b/gi],
+  ['las opciones', /\blas opciones\b/gi],
+  ['el resultado', /\bel resultado\b/gi],
+  ['método de extracción', /\bmétodo de extracción\b/gi],
+  ['uniformidad del molino', /\buniformidad del molino\b/gi],
+  ['café recién tostado', /\bcafé recién tostado\b/gi],
+] as const;
+
+type UnknownRecord = Record<string, unknown>;
+
+function normalize(value: string): string {
+  return value
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLocaleLowerCase('es');
+}
+
+function isTechnicalInvariant(text: string): boolean {
+  return [
+    'data:image/svg+xml;base64',
+    'background-image: url',
+    '.layout-playground {',
+    'const samplerate =',
+  ].some((pattern) => text.includes(pattern)) || (text.includes('presets') && text.includes('hz'));
+}
+
+function collectString(value: string, output: string[]): void {
+  const text = normalize(value);
+  if (!isTechnicalInvariant(text) && text.length >= 20) output.push(text);
+}
+
+function collectObject(value: UnknownRecord, output: string[]): void {
+  Object.entries(value).forEach(([childKey, childValue]) => {
+    collectText(childValue, output, childKey);
+  });
+}
+
+function collectText(value: unknown, output: string[], key?: string): void {
+  if (key && STRUCTURAL_KEYS.has(key)) return;
+  if (typeof value === 'string') return collectString(value, output);
+  if (Array.isArray(value)) return value.forEach((item) => collectText(item, output));
+  if (value && typeof value === 'object') collectObject(value as UnknownRecord, output);
+}
+
+async function loadText(loader: unknown): Promise<string[]> {
+  if (typeof loader !== 'function') return [];
+  const module = await (loader as () => Promise<unknown>)();
+  const output: string[] = [];
+  if (module && typeof module === 'object') {
+    const record = module as UnknownRecord;
+    for (const key of TRANSLATABLE_KEYS) {
+      collectText(record[key], output, key);
+    }
+  }
+  return output;
+}
+
+function findSpanishMarkers(text: string[]): string[] {
+  const corpus = text.join(' ');
+  return SPANISH_MARKERS.flatMap(([label, pattern]) =>
+    pattern.test(corpus) ? [label] : [],
+  );
+}
+
+function findCopiedFragments(spanish: string[], translated: string[]): string[] {
+  const corpus = translated.join(' ');
+  return spanish
+    .filter((fragment) => fragment.length >= 80 && corpus.includes(fragment))
+    .sort((a, b) => b.length - a.length)
+    .slice(0, 3);
+}
+
+describe('Locales must not contain copied Spanish content', () => {
+  for (const entry of ALL_ENTRIES) {
+    it(`${entry.id} has no untranslated Spanish blocks`, async () => {
+      const spanish = await loadText(entry.i18n.es);
+      const failures: string[] = [];
+
+      for (const [locale, loader] of Object.entries(entry.i18n)) {
+        if (locale === 'es') continue;
+
+        const translated = await loadText(loader);
+        const copiedFragments = findCopiedFragments(spanish, translated);
+        const markerHits = findSpanishMarkers(translated);
+
+        if (copiedFragments.length > 0 || markerHits.length >= 2) {
+          const details = [
+            copiedFragments.length > 0
+              ? `copied fragments: ${copiedFragments
+                  .map((fragment) => JSON.stringify(fragment.slice(0, 120)))
+                  .join(', ')}`
+              : '',
+            markerHits.length >= 2 ? `Spanish markers: ${markerHits.join(', ')}` : '',
+          ]
+            .filter(Boolean)
+            .join('; ');
+          failures.push(`${locale}: ${details}`);
+        }
+      }
+
+      expect(failures, failures.join('\n')).toEqual([]);
+    });
+  }
+});

package/src/tests/translation_copy.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+
+const COPY_THRESHOLD = 0.9;
+
+const STRUCTURAL_KEYS = new Set([
+  '@context',
+  '@type',
+  'applicationCategory',
+  'columns',
+  'highlight',
+  'icon',
+  'level',
+  'operatingSystem',
+  'position',
+  'positive',
+  'price',
+  'priceCurrency',
+  'slug',
+  'trend',
+  'type',
+  'url',
+  'value',
+  'variant',
+]);
+
+function normalizeText(value: string): string {
+  return value
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&(?:amp|lt|gt|quot|apos|nbsp);/gi, ' ')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201c\u201d]/g, '"')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLocaleLowerCase();
+}
+
+function collectText(value: unknown, path: string, parts: string[]): void {
+  if (typeof value === 'string') {
+    const normalized = normalizeText(value);
+    if (normalized.length >= 2) parts.push(normalized);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectText(item, `${path}[${index}]`, parts));
+    return;
+  }
+
+  if (!value || typeof value !== 'object') return;
+
+  Object.entries(value).forEach(([key, child]) => {
+    if (STRUCTURAL_KEYS.has(key)) return;
+    collectText(child, `${path}.${key}`, parts);
+  });
+}
+
+function localeCorpus(content: unknown): string {
+  if (!content || typeof content !== 'object') return '';
+
+  const record = content as Record<string, unknown>;
+  const parts: string[] = [];
+  collectText(record.title, 'title', parts);
+  collectText(record.description, 'description', parts);
+  collectText(record.faqTitle, 'faqTitle', parts);
+  collectText(record.faq, 'faq', parts);
+  collectText(record.seo, 'seo', parts);
+  collectText(record.schemas, 'schemas', parts);
+  return parts.join(' ');
+}
+
+function tokenCounts(text: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const token of text.match(/[\p{L}\p{N}]+/gu) ?? []) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function copySimilarity(left: string, right: string): number {
+  const leftCounts = tokenCounts(left);
+  const rightCounts = tokenCounts(right);
+  const leftTotal = [...leftCounts.values()].reduce((sum, count) => sum + count, 0);
+  const rightTotal = [...rightCounts.values()].reduce((sum, count) => sum + count, 0);
+  if (leftTotal === 0 || rightTotal === 0) return 0;
+
+  let shared = 0;
+  for (const [token, count] of leftCounts) {
+    shared += Math.min(count, rightCounts.get(token) ?? 0);
+  }
+  return (2 * shared) / (leftTotal + rightTotal);
+}
+
+describe('Locales must not copy another locale wholesale', () => {
+  ALL_ENTRIES.forEach((entry) => {
+    it(`${entry.id} is not at least ${COPY_THRESHOLD * 100}% identical to another locale`, async () => {
+      const corpora = new Map<string, string>();
+
+      for (const [locale, loader] of Object.entries(entry.i18n)) {
+        if (!loader) continue;
+        corpora.set(locale, localeCorpus(await loader()));
+      }
+
+      const locales = [...corpora.keys()];
+      const violations: string[] = [];
+
+      for (let leftIndex = 0; leftIndex < locales.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < locales.length; rightIndex += 1) {
+          const left = locales[leftIndex];
+          const right = locales[rightIndex];
+          const leftCorpus = corpora.get(left) ?? '';
+          const rightCorpus = corpora.get(right) ?? '';
+          const similarity = copySimilarity(leftCorpus, rightCorpus);
+
+          if (similarity >= COPY_THRESHOLD) {
+            violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
+          }
+        }
+      }
+
+      expect(violations, `Locale copy threshold exceeded in ${entry.id}`).toEqual([]);
+    });
+  });
+});
+

package/src/tool/socialValueCalculator/i18n/de.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Hinweis für Creator',
       html: '<p>Dieses Tool liefert Schätzwerte. Passen Sie den Preis immer an die Komplexität des angeforderten Inhalts an.</p>',
     },
+    { type: 'paragraph', html: 'Der berechnete Wert ist eine Orientierung, kein garantierter Verkaufspreis. Vergleiche mehrere Szenarien und ergänze aktuelle Zielgruppe, Engagement und Einnahmen, bevor du eine Geschäftsentscheidung triffst.' },
   ],
   ui: {
     sectionTag: 'Audit-Parameter',

package/src/tool/socialValueCalculator/i18n/id.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Catatan untuk Kreator',
       html: '<p>Alat ini adalah perkiraan. Selalu sesuaikan harga berdasarkan kompleksitas konten yang diminta oleh merek.</p>',
     },
+    { type: 'paragraph', html: 'Nilai akun adalah perkiraan, bukan harga jual yang dijamin. Bandingkan beberapa skenario dan pertimbangkan audiens, engagement, serta pendapatan terbaru sebelum mengambil keputusan.' },
   ],
   ui: {
     sectionTag: 'Parameter Audit',

package/src/tool/socialValueCalculator/i18n/it.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Nota per i Creatori',
       html: '<p>Questo strumento è una stima. Regola sempre il prezzo in base alla complessità dei contenuti richiesti dal brand.</p>',
     },
+    { type: 'paragraph', html: 'Il valore dell account è una stima, non un prezzo di vendita garantito. Confronta più scenari e considera pubblico, interazioni e ricavi aggiornati prima di decidere.' },
   ],
   ui: {
     sectionTag: 'Parametri Audit',

package/src/tool/socialValueCalculator/i18n/ja.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'クリエイターへの注意',
       html: '<p>このツールは推定値です。常にブランドから依頼されたコンテンツの複雑さに合わせて価格を調整してください。</p>',
     },
+    { type: 'paragraph', html: 'アカウント価値は売却価格を保証するものではなく、あくまで目安です。決定する前に複数のシナリオを比べ、フォロワー層、反応率、最新の収益も確認してください。' },
   ],
   ui: {
     sectionTag: '監査パラメータ',

package/src/tool/socialValueCalculator/i18n/ko.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: '크리에이터를 위한 참고 사항',
       html: '<p>이 도구는 추정치입니다. 브랜드가 요청하는 콘텐츠의 복잡도에 따라 가격을 항상 조정하십시오.</p>',
     },
+    { type: 'paragraph', html: '계산된 계정 가치는 보장된 판매 가격이 아니라 참고용 추정치입니다. 결정을 내리기 전에 여러 시나리오를 비교하고 잠재고객, 참여도, 최신 수익을 함께 확인하세요.' },
   ],
   ui: {
     sectionTag: '검토 파라미터',

package/src/tool/socialValueCalculator/i18n/nl.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Opmerking voor Creators',
       html: '<p>Deze tool is een schatting. Pas de prijs altijd aan op basis van de complexiteit van de door het merk gevraagde content.</p>',
     },
+    { type: 'paragraph', html: 'De berekende accountwaarde is een indicatie en geen gegarandeerde verkoopprijs. Vergelijk scenario\'s en controleer doelgroep, betrokkenheid en recente inkomsten voordat je beslist.' },
   ],
   ui: {
     sectionTag: 'Audit Parameters',

package/src/tool/socialValueCalculator/i18n/pl.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Notka dla twórców',
       html: '<p>To narzędzie podaje szacunki. Zawsze dostosowuj cenę do poziomu trudności materiału, o który prosi marka.</p>',
     },
+    { type: 'paragraph', html: 'Wyliczona wartość konta jest wskazówką, a nie gwarantowaną ceną sprzedaży. Przed decyzją porównaj scenariusze oraz sprawdź odbiorców, zaangażowanie i aktualne przychody.' },
   ],
   ui: {
     sectionTag: 'Parametry audytu',

package/src/tool/socialValueCalculator/i18n/pt.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Nota para Criadores',
       html: '<p>Esta ferramenta é uma estimativa. Ajuste sempre o preço com base na complexidade do conteúdo solicitado pela marca.</p>',
     },
+    { type: 'paragraph', html: 'O valor calculado da conta é uma orientação, não um preço de venda garantido. Compare vários cenários e confirme público, envolvimento e receitas recentes antes de decidir.' },
   ],
   ui: {
     sectionTag: 'Parâmetros de Auditoria',

package/src/tool/socialValueCalculator/i18n/ru.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Примечание для авторов',
       html: '<p>Этот инструмент дает оценку. Всегда корректируйте цену в зависимости от сложности контента, запрашиваемого брендом.</p>',
     },
+    { type: 'paragraph', html: 'Расчётная стоимость аккаунта является ориентиром, а не гарантированной ценой продажи. Перед решением сравните сценарии и проверьте аудиторию, вовлечённость и последние доходы.' },
   ],
   ui: {
     sectionTag: 'Параметры аудита',

package/src/tool/socialValueCalculator/i18n/sv.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Notering för skapare',
       html: '<p>Detta verktyg är en uppskattning. Justera alltid priset baserat på komplexiteten i det innehåll som varumärket efterfrågat.</p>',
     },
+    { type: 'paragraph', html: 'Det beräknade kontovärdet är en uppskattning, inte ett garanterat försäljningspris. Jämför scenarier och kontrollera målgrupp, engagemang och aktuella intäkter innan du beslutar.' },
   ],
   ui: {
     sectionTag: 'Granskningsparametrar',

package/src/tool/socialValueCalculator/i18n/tr.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: 'Üreticiler için Not',
       html: '<p>Bu araç bir tahmindir. Fiyatı her zaman marka tarafından talep edilen içeriğin karmaşıklığına göre ayarlayın.</p>',
     },
+    { type: 'paragraph', html: 'Hesaplanan hesap değeri garanti edilmiş satış fiyatı değil, bir tahmindir. Karar vermeden önce senaryoları karşılaştırın ve kitleyi, etkileşimi ve güncel geliri değerlendirin.' },
   ],
   ui: {
     sectionTag: 'Denetim Parametreleri',

package/src/tool/socialValueCalculator/i18n/zh.ts

@@ -257,6 +257,7 @@ export const content: ToolLocaleContent<SocialValueCalculatorUI> = {
       title: '创作者注',
       html: '<p>此工具仅为估算值。请务必根据品牌方要求的内容复杂程度调整价格。</p>',
     },
+    { type: 'paragraph', html: '计算出的账号价值只是参考估算，并不保证实际售价。做决定前请比较不同情景，并结合受众、互动率和最新收入进行判断。' },
   ],
   ui: {
     sectionTag: '审计参数',