@jjlmoya/utils-astronomy 1.24.0 → 1.26.0

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

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const ASIAN_LOCALES = ['ja', 'ko', 'zh'];
+
+function getSimpleSectionLength(section: any): number {
+  if (section.type === 'title') return section.text ? section.text.length : 0;
+  if (section.type === 'paragraph') return section.html ? section.html.replace(/<[^>]*>/g, '').length : 0;
+  if (section.type === 'list') return section.items ? section.items.join('').length : 0;
+  return 0;
+}
+
+function getComplexSectionLength(section: any): number {
+  if (section.type === 'diagnostic' || section.type === 'tip') {
+    return (section.title ? section.title.length : 0) + (section.html ? section.html.replace(/<[^>]*>/g, '').length : 0);
+  }
+  if (section.type === 'table') {
+    return ((section.headers || []).join('').length) + ((section.rows || []).flat().join('').length);
+  }
+  return 0;
+}
+
+function getSectionLength(section: any): number {
+  return getSimpleSectionLength(section) || getComplexSectionLength(section);
+}
+
+function calculateSeoTextLength(seoSections: any[]): number {
+  return seoSections.reduce((acc, section) => acc + getSectionLength(section), 0);
+}
+
+function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): string | null {
+  const isAsian = ASIAN_LOCALES.includes(locale);
+  const minLength = isAsian ? 240 : Math.max(600, Math.floor(enLen * 0.35));
+  const msgType = isAsian ? 'suspiciously short' : 'truncated/lazy';
+
+  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<string | null> {
+  if (locale === 'en' || !loader) return null;
+  const content = await loader();
+  if (!content.seo || !Array.isArray(content.seo)) return null;
+
+  return checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+}
+
+describe('SEO Translation Completeness & Laziness Audit', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should not have lazy or truncated SEO content compared to English reference', async () => {
+        const enLoader = entry.i18n['en' as keyof typeof entry.i18n];
+        if (!enLoader) return;
+
+        const enContent = await enLoader();
+        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)) {
+          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);
+    });
+  });
+});

package/src/tests/tool_structure.test.ts

@@ -1,71 +1,71 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-
-describe('Tool Structure Validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    const toolId = tool.entry.id;
-    const folderName = toolId.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-
-    it(`${toolId} should have complete file structure`, () => {
-      const toolDir = join(process.cwd(), 'src/tool', folderName);
-
-      const enPath = join(toolDir, 'i18n', 'en.ts');
-      const enContent = readFileSync(enPath, 'utf-8');
-      const slugMatch = enContent.match(/const slug = ['"]([^'"]+)['"]/);
-      const englishSlug = slugMatch?.[1];
-
-      expect(
-        englishSlug,
-        `${toolId} i18n/en.ts must have: const slug = '...';`,
-      ).toBeTruthy();
-
-      const requiredFiles = [
-        'index.ts',
-        'entry.ts',
-        'component.astro',
-        'seo.astro',
-        'bibliography.astro',
-        'bibliography.ts',
-        `${englishSlug}.css`,
-      ];
-
-      requiredFiles.forEach((file) => {
-        const filePath = join(toolDir, file);
-        expect(
-          existsSync(filePath),
-          `${toolId} is missing required file: ${file}`,
-        ).toBe(true);
-      });
-
-      const indexPath = join(toolDir, 'index.ts');
-      const indexContent = readFileSync(indexPath, 'utf-8');
-      expect(
-        indexContent.includes('SEOComponent'),
-        `${toolId}/index.ts missing SEOComponent export`,
-      ).toBe(true);
-      expect(
-        indexContent.includes('BibliographyComponent'),
-        `${toolId}/index.ts missing BibliographyComponent export`,
-      ).toBe(true);
-    });
-
-    it(`${toolId} seo.astro should use SEORenderer from shared`, () => {
-      const seoPath = join(process.cwd(), 'src/tool', folderName, 'seo.astro');
-      const content = readFileSync(seoPath, 'utf-8');
-      expect(
-        content.includes("import { SEORenderer } from '@jjlmoya/utils-shared'"),
-        `${toolId}/seo.astro should import SEORenderer from shared`,
-      ).toBe(true);
-    });
-
-    it(`${toolId} bibliography.astro should exist`, () => {
-      const bibPath = join(process.cwd(), 'src/tool', folderName, 'bibliography.astro');
-      expect(
-        existsSync(bibPath),
-        `${toolId} is missing bibliography.astro`,
-      ).toBe(true);
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+describe('Tool Structure Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    const toolId = tool.entry.id;
+    const folderName = toolId.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+
+    it(`${toolId} should have complete file structure`, () => {
+      const toolDir = join(process.cwd(), 'src/tool', folderName);
+
+      const enPath = join(toolDir, 'i18n', 'en.ts');
+      const enContent = readFileSync(enPath, 'utf-8');
+      const slugMatch = enContent.match(/const slug = ['"]([^'"]+)['"]/);
+      const englishSlug = slugMatch?.[1];
+
+      expect(
+        englishSlug,
+        `${toolId} i18n/en.ts must have: const slug = '...';`,
+      ).toBeTruthy();
+
+      const requiredFiles = [
+        'index.ts',
+        'entry.ts',
+        'component.astro',
+        'seo.astro',
+        'bibliography.astro',
+        'bibliography.ts',
+        `${englishSlug}.css`,
+      ];
+
+      requiredFiles.forEach((file) => {
+        const filePath = join(toolDir, file);
+        expect(
+          existsSync(filePath),
+          `${toolId} is missing required file: ${file}`,
+        ).toBe(true);
+      });
+
+      const indexPath = join(toolDir, 'index.ts');
+      const indexContent = readFileSync(indexPath, 'utf-8');
+      expect(
+        indexContent.includes('SEOComponent'),
+        `${toolId}/index.ts missing SEOComponent export`,
+      ).toBe(true);
+      expect(
+        indexContent.includes('BibliographyComponent'),
+        `${toolId}/index.ts missing BibliographyComponent export`,
+      ).toBe(true);
+    });
+
+    it(`${toolId} seo.astro should use SEORenderer from shared`, () => {
+      const seoPath = join(process.cwd(), 'src/tool', folderName, 'seo.astro');
+      const content = readFileSync(seoPath, 'utf-8');
+      expect(
+        content.includes("import { SEORenderer } from '@jjlmoya/utils-shared'"),
+        `${toolId}/seo.astro should import SEORenderer from shared`,
+      ).toBe(true);
+    });
+
+    it(`${toolId} bibliography.astro should exist`, () => {
+      const bibPath = join(process.cwd(), 'src/tool', folderName, 'bibliography.astro');
+      expect(
+        existsSync(bibPath),
+        `${toolId} is missing bibliography.astro`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

@@ -1,146 +1,146 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ALL_TOOLS } from '../tools';
-import { astronomyCategory } from '../data';
-import type { ToolDefinition } from '../types';
-
-function extractSeoText(sections: any[]): string {
-  return sections
-    .map((section) => extractSectionText(section))
-    .join(' ');
-}
-
-function extractHtmlOrText(section: any): string {
-  const hasContent = 'html' in section || 'text' in section;
-  const isNotTable = section.type !== 'table';
-  return hasContent && isNotTable ? (section.html || section.text || '') : '';
-}
-
-function extractListItems(section: any): string {
-  return 'items' in section && Array.isArray(section.items) ? section.items.join(' ') : '';
-}
-
-function extractTableRows(section: any): string {
-  return 'rows' in section && Array.isArray(section.rows) ? section.rows.flat().join(' ') : '';
-}
-
-function extractSectionText(section: any): string {
-  let text = '';
-  text += extractHtmlOrText(section);
-  text += extractListItems(section);
-  text += extractTableRows(section);
-  return text;
-}
-
-function countWords(text: string): number {
-  const cleanText = text.replace(/<[^>]*>/g, '').trim();
-  const standardWords = cleanText.split(/\s+/).filter((w) => w.length > 0).length;
-  const cjkChars = cleanText.match(/[\u4e00-\u9fa5\u3040-\u30ff\uac00-\ud7af]/g)?.length || 0;
-  const cjkBlocks = cleanText.split(/[^\u4e00-\u9fa5\u3040-\u30ff\uac00-\ud7af]+/).filter(w => w.length > 0).length;
-  return standardWords - cjkBlocks + cjkChars;
-}
-
-describe('Tool Validation Suite', () => {
-  describe('Strict Tool Definition Validation', () => {
-    ALL_TOOLS.forEach((tool: ToolDefinition) => {
-      const { entry } = tool;
-
-      describe(`${entry.id} structure`, () => {
-        it('should fulfill ToolDefinition interface', () => {
-          expect(tool.entry).toBeDefined();
-          expect(tool.Component).toBeDefined();
-          expect(tool.SEOComponent).toBeDefined();
-          expect(tool.BibliographyComponent).toBeDefined();
-        });
-
-        it('should have valid ID in kebab-case', () => {
-          expect(entry.id).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
-        });
-
-        it('should have valid icons with bg and fg', () => {
-          expect(entry.icons.bg).toMatch(/^mdi:/);
-          expect(entry.icons.fg).toMatch(/^mdi:/);
-        });
-
-        describe('i18n Content Validation', () => {
-          Object.entries(entry.i18n).forEach(([locale, loader]) => {
-            it(`should load ${locale} content and follow slug rules`, async () => {
-              const content = await loader();
-              expect(content.slug).toBeDefined();
-              expect(content.slug).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
-
-              if (locale === 'es') {
-                const validSlugs = [
-                  'simulador-cielo-oscuro',
-                  'alcance-telescopio',
-                  'calculadora-regla-500',
-                  'calculadora-resolucion-telescopio',
-                  'calculadora-oculares',
-                ];
-                expect(validSlugs).toContain(content.slug);
-              }
-            });
-
-            it(`should have valid basic content in ${locale}`, async () => {
-              const content = await loader();
-              expect(content.title.length).toBeGreaterThan(0);
-              expect(content.description.length).toBeGreaterThan(0);
-              expect(Object.keys(content.ui).length).toBeGreaterThan(0);
-            });
-
-            it(`should have SEO content with > 300 words in ${locale}`, async () => {
-              const content = await loader();
-              const seoText = extractSeoText(content.seo);
-              const wordCount = countWords(seoText);
-              expect(wordCount).toBeGreaterThanOrEqual(300);
-            });
-          });
-        });
-      });
-    });
-  });
-
-  describe('Library Registration', () => {
-    it('should have 5 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(5);
-    });
-
-    it('should have all tools in astronomyCategory', () => {
-      expect(astronomyCategory.tools.length).toBe(5);
-      ALL_TOOLS.forEach(({ entry }) => {
-        const exists = astronomyCategory.tools.some((t: any) => t.id === entry.id);
-        expect(exists).toBe(true);
-      });
-    });
-  });
-
-  describe('Binary Consistency', () => {
-    ALL_TOOLS.forEach(({ entry }) => {
-      it(`${entry.id} files should exist in the tool folder`, () => {
-        const toolVarName = (entry.id ?? '').replace(/-([a-z])/g, (_: string, g: string) => g.toUpperCase());
-        const toolDir = path.join('src', 'tool', toolVarName);
-
-        expect(fs.existsSync(path.join(toolDir, 'component.astro'))).toBe(true);
-        expect(fs.existsSync(path.join(toolDir, 'seo.astro'))).toBe(true);
-        expect(fs.existsSync(path.join(toolDir, 'bibliography.astro'))).toBe(true);
-        expect(fs.existsSync(path.join(toolDir, 'index.ts'))).toBe(true);
-      });
-    });
-  });
-
-  describe('Bibliography Components Structure', () => {
-    ALL_TOOLS.forEach(({ entry }) => {
-      it(`${entry.id} should have a standard bibliography structure`, () => {
-        const toolVarName = (entry.id ?? '').replace(/-([a-z])/g, (_: string, g: string) => g.toUpperCase());
-        const componentPath = path.join('src', 'tool', toolVarName, 'bibliography.astro');
-        const content = fs.readFileSync(componentPath, 'utf-8');
-
-        expect(content).toContain("import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared'");
-        expect(content).toContain(`import { ${toolVarName} } from './index'`);
-        expect(content).toContain('<SharedBibliography links={content.bibliography} />');
-      });
-    });
-  });
-});
-
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ALL_TOOLS } from '../tools';
+import { astronomyCategory } from '../data';
+import type { ToolDefinition } from '../types';
+
+function extractSeoText(sections: any[]): string {
+  return sections
+    .map((section) => extractSectionText(section))
+    .join(' ');
+}
+
+function extractHtmlOrText(section: any): string {
+  const hasContent = 'html' in section || 'text' in section;
+  const isNotTable = section.type !== 'table';
+  return hasContent && isNotTable ? (section.html || section.text || '') : '';
+}
+
+function extractListItems(section: any): string {
+  return 'items' in section && Array.isArray(section.items) ? section.items.join(' ') : '';
+}
+
+function extractTableRows(section: any): string {
+  return 'rows' in section && Array.isArray(section.rows) ? section.rows.flat().join(' ') : '';
+}
+
+function extractSectionText(section: any): string {
+  let text = '';
+  text += extractHtmlOrText(section);
+  text += extractListItems(section);
+  text += extractTableRows(section);
+  return text;
+}
+
+function countWords(text: string): number {
+  const cleanText = text.replace(/<[^>]*>/g, '').trim();
+  const standardWords = cleanText.split(/\s+/).filter((w) => w.length > 0).length;
+  const cjkChars = cleanText.match(/[\u4e00-\u9fa5\u3040-\u30ff\uac00-\ud7af]/g)?.length || 0;
+  const cjkBlocks = cleanText.split(/[^\u4e00-\u9fa5\u3040-\u30ff\uac00-\ud7af]+/).filter(w => w.length > 0).length;
+  return standardWords - cjkBlocks + cjkChars;
+}
+
+describe('Tool Validation Suite', () => {
+  describe('Strict Tool Definition Validation', () => {
+    ALL_TOOLS.forEach((tool: ToolDefinition) => {
+      const { entry } = tool;
+
+      describe(`${entry.id} structure`, () => {
+        it('should fulfill ToolDefinition interface', () => {
+          expect(tool.entry).toBeDefined();
+          expect(tool.Component).toBeDefined();
+          expect(tool.SEOComponent).toBeDefined();
+          expect(tool.BibliographyComponent).toBeDefined();
+        });
+
+        it('should have valid ID in kebab-case', () => {
+          expect(entry.id).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
+        });
+
+        it('should have valid icons with bg and fg', () => {
+          expect(entry.icons.bg).toMatch(/^mdi:/);
+          expect(entry.icons.fg).toMatch(/^mdi:/);
+        });
+
+        describe('i18n Content Validation', () => {
+          Object.entries(entry.i18n).forEach(([locale, loader]) => {
+            it(`should load ${locale} content and follow slug rules`, async () => {
+              const content = await loader();
+              expect(content.slug).toBeDefined();
+              expect(content.slug).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
+
+              if (locale === 'es') {
+                const validSlugs = [
+                  'simulador-cielo-oscuro',
+                  'alcance-telescopio',
+                  'calculadora-regla-500',
+                  'calculadora-resolucion-telescopio',
+                  'calculadora-oculares',
+                ];
+                expect(validSlugs).toContain(content.slug);
+              }
+            });
+
+            it(`should have valid basic content in ${locale}`, async () => {
+              const content = await loader();
+              expect(content.title.length).toBeGreaterThan(0);
+              expect(content.description.length).toBeGreaterThan(0);
+              expect(Object.keys(content.ui).length).toBeGreaterThan(0);
+            });
+
+            it(`should have SEO content with > 300 words in ${locale}`, async () => {
+              const content = await loader();
+              const seoText = extractSeoText(content.seo);
+              const wordCount = countWords(seoText);
+              expect(wordCount).toBeGreaterThanOrEqual(300);
+            });
+          });
+        });
+      });
+    });
+  });
+
+  describe('Library Registration', () => {
+    it('should have 5 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(5);
+    });
+
+    it('should have all tools in astronomyCategory', () => {
+      expect(astronomyCategory.tools.length).toBe(5);
+      ALL_TOOLS.forEach(({ entry }) => {
+        const exists = astronomyCategory.tools.some((t: any) => t.id === entry.id);
+        expect(exists).toBe(true);
+      });
+    });
+  });
+
+  describe('Binary Consistency', () => {
+    ALL_TOOLS.forEach(({ entry }) => {
+      it(`${entry.id} files should exist in the tool folder`, () => {
+        const toolVarName = (entry.id ?? '').replace(/-([a-z])/g, (_: string, g: string) => g.toUpperCase());
+        const toolDir = path.join('src', 'tool', toolVarName);
+
+        expect(fs.existsSync(path.join(toolDir, 'component.astro'))).toBe(true);
+        expect(fs.existsSync(path.join(toolDir, 'seo.astro'))).toBe(true);
+        expect(fs.existsSync(path.join(toolDir, 'bibliography.astro'))).toBe(true);
+        expect(fs.existsSync(path.join(toolDir, 'index.ts'))).toBe(true);
+      });
+    });
+  });
+
+  describe('Bibliography Components Structure', () => {
+    ALL_TOOLS.forEach(({ entry }) => {
+      it(`${entry.id} should have a standard bibliography structure`, () => {
+        const toolVarName = (entry.id ?? '').replace(/-([a-z])/g, (_: string, g: string) => g.toUpperCase());
+        const componentPath = path.join('src', 'tool', toolVarName, 'bibliography.astro');
+        const content = fs.readFileSync(componentPath, 'utf-8');
+
+        expect(content).toContain("import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared'");
+        expect(content).toContain(`import { ${toolVarName} } from './index'`);
+        expect(content).toContain('<SharedBibliography links={content.bibliography} />');
+      });
+    });
+  });
+});
+

package/src/tool/bortleVisualizer/bibliography.astro

@@ -1,14 +1,14 @@
----
-import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
-import { bortleVisualizer } from './index';
-import type { KnownLocale } from '../../types';
-
-interface Props {
-  locale?: KnownLocale;
-}
-
-const { locale = 'es' } = Astro.props;
-const content = await bortleVisualizer.i18n[locale]?.();
----
-
-{content && <SharedBibliography links={content.bibliography} />}
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bortleVisualizer } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await bortleVisualizer.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/bortleVisualizer/bibliography.ts

@@ -1,8 +1,8 @@
-import type { BibliographyEntry } from '../../types';
-
-export const bibliography: BibliographyEntry[] = [
-  { name: 'Gauging Light Pollution: The Bortle Dark-Sky Scale', url: 'https://skyandtelescope.org/astronomy-resources/light-pollution-and-astronomy-the-bortle-dark-sky-scale/' },
-  { name: 'Light pollution map', url: 'https://www.lightpollutionmap.info/' },
-  { name: 'International Dark-Sky Association', url: 'https://www.darksky.org/' },
-  { name: 'Globe at Night', url: 'https://www.globeatnight.org/' },
-];
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  { name: 'Gauging Light Pollution: The Bortle Dark-Sky Scale', url: 'https://skyandtelescope.org/astronomy-resources/light-pollution-and-astronomy-the-bortle-dark-sky-scale/' },
+  { name: 'Light pollution map', url: 'https://www.lightpollutionmap.info/' },
+  { name: 'International Dark-Sky Association', url: 'https://www.darksky.org/' },
+  { name: 'Globe at Night', url: 'https://www.globeatnight.org/' },
+];