@jjlmoya/utils-civic 1.8.0 → 1.9.0

package/src/mfe/routes.ts

@@ -0,0 +1,50 @@
+import {
+    getCategoryNamespace,
+    getCategoryPath as getSharedCategoryPath,
+    getUtilitiesPath as getSharedUtilitiesPath,
+    getUtilityNamespace,
+    getUtilityPath as getSharedUtilityPath,
+    type UtilityLocale,
+} from "@jjlmoya/utils-shared/routing";
+
+export type { UtilityLocale };
+export { getCategoryNamespace, getUtilityNamespace };
+
+export const INTERNAL_LOCALES = [
+    "en", "fr", "de", "it", "pt", "nl", "sv", "pl", "id", "tr", "ru", "ja", "ko", "zh",
+] as const satisfies readonly UtilityLocale[];
+
+const getDevelopmentPath = (url: string): string => {
+    if (!import.meta.env.DEV) return url;
+    try {
+        return new URL(url, "http://localhost:4324").pathname;
+    } catch {
+        return url;
+    }
+};
+
+export const getUtilitiesPath = (locale: UtilityLocale): string =>
+    getDevelopmentPath(getSharedUtilitiesPath(locale));
+
+export const getCategoryPath = (locale: UtilityLocale, categorySlug: string): string =>
+    getDevelopmentPath(getSharedCategoryPath(locale, categorySlug));
+
+export const getUtilityPath = (
+    locale: UtilityLocale,
+    categorySlug: string,
+    toolSlug: string,
+): string => getDevelopmentPath(getSharedUtilityPath(locale, categorySlug, toolSlug));
+
+export const getCategoryRoute = (locale: UtilityLocale, categorySlug: string): string =>
+    getCategoryPath(locale, categorySlug);
+
+export const getUtilityRoute = (locale: UtilityLocale, categorySlug: string, toolSlug: string): string =>
+    getUtilityPath(locale, categorySlug, toolSlug);
+
+export const getUtilityIndexRoute = (locale: UtilityLocale): string => getUtilitiesPath(locale);
+
+export const getInternalCategoryRoute = (locale: Exclude<UtilityLocale, "es">, categorySlug: string): string =>
+    getCategoryPath(locale, categorySlug);
+
+export const getInternalUtilityRoute = (locale: Exclude<UtilityLocale, "es">, categorySlug: string, toolSlug: string): string =>
+    getUtilityPath(locale, categorySlug, toolSlug);

package/src/pages/[locale]/[utilities]/[categories]/[category]/[slug].astro

@@ -0,0 +1,100 @@
+---
+import ProductionUtilityPage from "../../../../../layouts/ProductionUtilityPage.astro";
+import { ALL_TOOLS, civicCategory } from "../../../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../../../i18n/languages";
+import type { CategoryLocaleContent, ToolLocaleContent } from "../../../../../types";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+import { getCategoryNamespace, getCategoryPath, getUtilityNamespace, getUtilityPath } from "../../../../../mfe/routes";
+import { getUtilityOgImage } from "../../../../../mfe/assets";
+
+type Loader<T> = () => Promise<{ default: T }>;
+type LoadedTool = ToolLocaleContent;
+
+export async function getStaticPaths() {
+    const paths = [];
+    for (const { entry, Component: componentLoader, SEOComponent: seoLoader, BibliographyComponent: bibliographyLoader } of ALL_TOOLS) {
+        const contents = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => {
+            const loader = entry.i18n[language] ?? entry.i18n.en;
+            if (!loader) throw new Error(`Missing ${language} locale for ${entry.id}`);
+            return [language, await loader()];
+        }))) as Record<Language, LoadedTool>;
+        const categories = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+            language,
+            await civicCategory.i18n[language]!(),
+        ]))) as Record<Language, CategoryLocaleContent>;
+        const { default: Component } = await (componentLoader as Loader<AstroComponentFactory>)();
+        const { default: SEOComponent } = await (seoLoader as Loader<AstroComponentFactory>)();
+        const { default: BibliographyComponent } = await (bibliographyLoader as Loader<AstroComponentFactory>)();
+        for (const locale of LANGUAGE_CODES.filter((candidate) => candidate !== "es")) {
+            const content = contents[locale];
+            const category = categories[locale];
+            paths.push({
+                params: {
+                    locale,
+                    utilities: getUtilityNamespace(locale),
+                    categories: getCategoryNamespace(locale),
+                    category: category.slug,
+                    slug: content.slug,
+                },
+                props: {
+                    locale,
+                    content,
+                    englishSlug: contents.en.slug,
+                    category,
+                    categorySlug: category.slug,
+                    Component,
+                    SEOComponent,
+                    BibliographyComponent,
+                    alternates: LANGUAGE_CODES.map((language) => ({
+                        language,
+                        url: getUtilityPath(language, categories[language].slug, contents[language].slug),
+                    })),
+                    image: getUtilityOgImage(contents.en.slug),
+                },
+            });
+        }
+    }
+    return paths;
+}
+
+const { locale, content, englishSlug, category, categorySlug, Component, SEOComponent, BibliographyComponent, relatedTools, alternates, image } = Astro.props as {
+    locale: Exclude<Language, "es">;
+    content: LoadedTool;
+    englishSlug: string;
+    category: CategoryLocaleContent;
+    categorySlug: string;
+    Component: AstroComponentFactory;
+    SEOComponent: AstroComponentFactory;
+    BibliographyComponent: AstroComponentFactory;
+    relatedTools?: { icon: string; title: string; description: string; href: string }[];
+    alternates: { language: Language; url: string }[];
+    image?: string;
+};
+const related = relatedTools ?? (await Promise.all(ALL_TOOLS.map(async ({ entry: relatedEntry }) => {
+    const loader = relatedEntry.i18n[locale] ?? relatedEntry.i18n.en;
+    if (!loader) return null;
+    const relatedContent = await loader();
+    if (relatedContent.slug === content.slug) return null;
+    return {
+        icon: relatedEntry.icons.fg,
+        title: relatedContent.title,
+        description: relatedContent.description,
+        href: getUtilityPath(locale, categorySlug, relatedContent.slug),
+    };
+}))).filter((tool): tool is { icon: string; title: string; description: string; href: string } => tool !== null);
+---
+
+<ProductionUtilityPage
+    {locale}
+    {content}
+    {englishSlug}
+    categoryTitle={category.title}
+    {categorySlug}
+    categoryHref={getCategoryPath(locale, categorySlug)}
+    relatedTools={related}
+    {Component}
+    {SEOComponent}
+    {BibliographyComponent}
+    {alternates}
+    {image}
+/> 

package/src/pages/[locale]/[utilities]/[categories]/[category].astro

@@ -0,0 +1,44 @@
+---
+import ProductionCategoryPage from "../../../../layouts/ProductionCategoryPage.astro";
+import { ALL_TOOLS, civicCategory } from "../../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../../i18n/languages";
+import { getCategoryNamespace, getCategoryPath, getUtilityNamespace, getUtilityPath } from "../../../../mfe/routes";
+import { CATEGORY_OG_IMAGE } from "../../../../mfe/assets";
+
+export async function getStaticPaths() {
+    const categories = Object.fromEntries(await Promise.all(
+        LANGUAGE_CODES.map(async (language) => [language, await civicCategory.i18n[language]!()]),
+    ));
+    return LANGUAGE_CODES.filter((language) => language !== "es").map((locale) => {
+        const category = categories[locale]!;
+        const alternates = LANGUAGE_CODES.map((language) => ({
+            language,
+            url: getCategoryPath(language, categories[language]!.slug),
+        }));
+        return {
+            params: { locale, utilities: getUtilityNamespace(locale), categories: getCategoryNamespace(locale), category: category.slug },
+            props: { locale, category, alternates },
+        };
+    });
+}
+
+const { locale, category, alternates } = Astro.props as {
+    locale: Exclude<Language, "es">;
+    category: Awaited<ReturnType<NonNullable<(typeof civicCategory.i18n)[Language]>>>;
+    alternates: { language: Language; url: string }[];
+};
+const tools = await Promise.all(ALL_TOOLS.map(async ({ entry }) => {
+    const loader = entry.i18n[locale] ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing ${locale} locale for ${entry.id}`);
+    const content = await loader();
+    return {
+        id: entry.id,
+        icon: entry.icons.fg,
+        title: content.title,
+        description: content.description,
+        href: getUtilityPath(locale, category.slug, content.slug),
+    };
+}));
+---
+
+<ProductionCategoryPage locale={locale} {category} {tools} {alternates} image={CATEGORY_OG_IMAGE} />

package/src/pages/index.astro

@@ -1,4 +1,4 @@
 ---
 ---
-<meta http-equiv="refresh" content="0;url=/es" />
+<meta http-equiv="refresh" content="0;url=/utilidades/categorias/civico/" />
 

package/src/pages/utilidades/[slug].astro

@@ -0,0 +1,90 @@
+---
+import ProductionUtilityPage from "../../layouts/ProductionUtilityPage.astro";
+import { ALL_TOOLS, civicCategory } from "../../index";
+import { LANGUAGE_CODES, type Language } from "../../i18n/languages";
+import type { CategoryLocaleContent, ToolLocaleContent } from "../../types";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+import { getCategoryPath, getUtilityPath } from "../../mfe/routes";
+import { getUtilityOgImage } from "../../mfe/assets";
+
+type Loader<T> = () => Promise<{ default: T }>;
+type LoadedTool = ToolLocaleContent;
+
+export async function getStaticPaths() {
+    const category = await civicCategory.i18n.es!();
+    const categories = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+        language,
+        await civicCategory.i18n[language]!(),
+    ]))) as Record<Language, CategoryLocaleContent>;
+    const paths = [];
+    for (const { entry, Component: componentLoader, SEOComponent: seoLoader, BibliographyComponent: bibliographyLoader } of ALL_TOOLS) {
+        const contents = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => {
+            const loader = entry.i18n[language] ?? entry.i18n.en;
+            if (!loader) throw new Error(`Missing ${language} locale for ${entry.id}`);
+            return [language, await loader()];
+        }))) as Record<Language, LoadedTool>;
+        const { default: Component } = await (componentLoader as Loader<AstroComponentFactory>)();
+        const { default: SEOComponent } = await (seoLoader as Loader<AstroComponentFactory>)();
+        const { default: BibliographyComponent } = await (bibliographyLoader as Loader<AstroComponentFactory>)();
+        paths.push({
+            params: { slug: contents.es.slug },
+            props: {
+                locale: "es",
+                content: contents.es,
+                englishSlug: contents.en.slug,
+                category,
+                categorySlug: category.slug,
+                Component,
+                SEOComponent,
+                BibliographyComponent,
+                alternates: LANGUAGE_CODES.map((language) => ({
+                    language,
+                    url: getUtilityPath(language, categories[language].slug, contents[language].slug),
+                })),
+                image: getUtilityOgImage(contents.en.slug),
+            },
+        });
+    }
+    return paths;
+}
+
+const { locale, content, englishSlug, category, categorySlug, Component, SEOComponent, BibliographyComponent, alternates, image } = Astro.props as {
+    locale: "es";
+    content: LoadedTool;
+    englishSlug: string;
+    category: CategoryLocaleContent;
+    categorySlug: string;
+    Component: AstroComponentFactory;
+    SEOComponent: AstroComponentFactory;
+    BibliographyComponent: AstroComponentFactory;
+    alternates: { language: Language; url: string }[];
+    image?: string;
+};
+const relatedTools = (await Promise.all(ALL_TOOLS.map(async ({ entry: relatedEntry }) => {
+    const loader = relatedEntry.i18n.es ?? relatedEntry.i18n.en;
+    if (!loader) return null;
+    const relatedContent = await loader();
+    if (relatedContent.slug === content.slug) return null;
+    return {
+        icon: relatedEntry.icons.fg,
+        title: relatedContent.title,
+        description: relatedContent.description,
+        href: getUtilityPath("es", categorySlug, relatedContent.slug),
+    };
+}))).filter((tool): tool is { icon: string; title: string; description: string; href: string } => tool !== null);
+---
+
+<ProductionUtilityPage
+    {locale}
+    {content}
+    {englishSlug}
+    categoryTitle={category.title}
+    {categorySlug}
+    categoryHref={getCategoryPath(locale, categorySlug)}
+    {relatedTools}
+    {Component}
+    {SEOComponent}
+    {BibliographyComponent}
+    {alternates}
+    {image}
+/> 

package/src/pages/utilidades/categorias/[category].astro

@@ -0,0 +1,38 @@
+---
+import ProductionCategoryPage from "../../../layouts/ProductionCategoryPage.astro";
+import { ALL_TOOLS, civicCategory } from "../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../i18n/languages";
+import { getCategoryPath, getUtilityPath } from "../../../mfe/routes";
+import { CATEGORY_OG_IMAGE } from "../../../mfe/assets";
+
+export async function getStaticPaths() {
+    const categories = Object.fromEntries(await Promise.all(
+        LANGUAGE_CODES.map(async (language) => [language, await civicCategory.i18n[language]!()]),
+    ));
+    const category = categories.es!;
+    const alternates = LANGUAGE_CODES.map((language) => ({
+        language,
+        url: getCategoryPath(language, categories[language]!.slug),
+    }));
+    return [{ params: { category: category.slug }, props: { category, alternates } }];
+}
+
+const { category, alternates } = Astro.props as {
+    category: Awaited<ReturnType<NonNullable<(typeof civicCategory.i18n)[Language]>>>;
+    alternates: { language: Language; url: string }[];
+};
+const tools = await Promise.all(ALL_TOOLS.map(async ({ entry }) => {
+    const loader = entry.i18n.es ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing Spanish locale for ${entry.id}`);
+    const content = await loader();
+    return {
+        id: entry.id,
+        icon: entry.icons.fg,
+        title: content.title,
+        description: content.description,
+        href: getUtilityPath("es", category.slug, content.slug),
+    };
+}));
+---
+
+<ProductionCategoryPage locale="es" {category} {tools} {alternates} image={CATEGORY_OG_IMAGE} />

package/src/tests/locale_completeness.test.ts

@@ -18,6 +18,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(8);
+    expect(ALL_TOOLS.length).toBe(9);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { civicCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(8);
+      expect(ALL_TOOLS.length).toBe(9);
     });
 
     it('civicCategory should be defined', () => {