@jjlmoya/utils-astronomy 1.19.0 → 1.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-astronomy",
-    "version": "1.19.0",
+    "version": "1.21.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/translation_copy.test.ts

@@ -0,0 +1,123 @@
+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 similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
+
+          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/bortleVisualizer/i18n/es.ts

@@ -74,11 +74,7 @@ const seo: BortleVisualizerLocaleContent['seo'] = [
   { type: 'title', text: 'Contaminación Lumínica: Una Crisis Global Silenciosa', level: 2 },
   {
     type: 'paragraph',
-    html: 'El crecimiento de la contaminación lumínica es uno de los problemas medioambientales menos discutidos pero más extendidos. Según estudios recientes, más del <strong>80% de la población mundial</strong> vive bajo cielos contaminados lumínicamente, y en Europa y Norteamérica el porcentaje supera el 99%. En España, la situación varía enormemente: desde las ciudades costeras con Bortle 8-9 hasta las zonas protegidas de la España interior con Bortle 2-3.',
-  },
-  {
-    type: 'paragraph',
-    html: 'Las consecuencias van más allá de la astronomía. La <strong>luz artificial nocturna</strong> altera los ritmos circadianos de humanos y animales, desorienta a aves migratorias, afecta a la reproducción de tortugas marinas y suprime la producción de melatonina en mamíferos. La IDA (International Dark-Sky Association) trabaja para designar Reservas de Cielo Oscuro en todo el mundo, y en España el programa Starlight ha certificado varias zonas de excelencia astronómica.',
+    html: 'El crecimiento de la contaminación lumínica es uno de los problemas medioambientales menos discutidos pero más extendidos. Según estudios recientes, más del <strong>80% de la población mundial</strong> vive bajo cielos contaminados lumínicamente. Las consecuencias van más allá de la astronomía: la luz artificial nocturna altera los ritmos circadianos y la biodiversidad.',
   },
   {
     type: 'table',

package/src/tool/starExposureCalculator/i18n/fr.ts

@@ -73,6 +73,11 @@ const seo: StarExposureCalculatorLocaleContent['seo'] = [
     type: 'paragraph',
     html: 'La <strong>Règle des 500</strong> est une formule empirique simplifiée qui a été la norme en astrophotographie de paysage depuis des décennies. Sa formule est: <code>Temps = 500 / (Longueur Focale × Facteur de Recadrage)</code>. Elle est rapide, mentale et suffisamment précise pour les capteurs basse résolution et la visualisation en petits formats.',
   },
+  { type: 'title', text: 'Le Facteur de Recadrage et son Impact', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Beaucoup de débutants oublient que la Règle des 500 est basée sur le standard 35mm (Plein Format). Si votre appareil photo a un capteur plus petit, le champ de vision est plus étroit et le mouvement des étoiles est amplifié. Un objectif de 14mm sur un APS-C (recadrage 1,5x) se comporte comme un 21mm équivalent, réduisant le temps maximum de 35.7s à seulement 23.8s.',
+  },
   { type: 'title', text: 'Le Modèle NPF: Précision pour Capteurs Modernes', level: 2 },
   {
     type: 'paragraph',

package/src/tool/telescopeResolution/i18n/es.ts

@@ -106,6 +106,11 @@ const seo: TelescopeResolutionLocaleContent['seo'] = [
     type: 'paragraph',
     html: 'Un telescopio mal colimado (con los espejos desalineados) nunca rendirá al límite de Dawes, independientemente de la apertura. La <strong>colimación</strong> es el proceso de alinear perfectamente los espejos secundario y primario con el portaocular. Para telescopios reflectores (Newtonianos, Dobsonianos), la colimación es una tarea periódica imprescindible. Practica la colimación en la estrella artificial de Polaris o en una estrella brillante usando la técnica del "star test".',
   },
+  { type: 'title', text: 'Consejos Prácticos para Maximizar la Resolución', level: 2 },
+  {
+    type: 'paragraph',
+    html: 'Más allá de la apertura y la colimación, varios hábitos de observación mejoran drásticamente la resolución práctica. Espera siempre a que el telescopio alcance el equilibrio térmico con el aire exterior (30-60 minutos). Evita observar sobre tejados, aparcamientos o superficies que irradien calor. Elige noches tras el paso de frentes fríos con capas atmosféricas estables. Usa el aumento más alto que mantenga una imagen estable y permite 20 minutos de adaptación a la oscuridad.',
+  },
   {
     type: 'stats',
     columns: 2,