@jjlmoya/utils-converters 1.26.0 → 1.28.0

package/src/pages/mfe-sitemaps/[locale]/[vertical]/sitemap.xml.ts

@@ -0,0 +1,75 @@
+import type { APIRoute } from "astro";
+import { convertersCategory } from "../../../../category";
+import { ALL_ENTRIES } from "../../../../entries";
+import { LANGUAGE_CODES, type Language } from "../../../../i18n/languages";
+import { getCategoryPath, getUtilityPath } from "../../../../mfe/routes";
+
+const GAMEBOB_URL = "https://www.gamebob.dev";
+const JJLMOYA_URL = "https://www.jjlmoya.es";
+
+type LocalizedEntry = {
+    i18n: Partial<Record<Language, () => Promise<{ slug: string }>>>;
+};
+
+const absoluteUrl = (locale: Language, path: string): string =>
+    path.startsWith("http") ? path : `${locale === "es" ? JJLMOYA_URL : GAMEBOB_URL}${path}`;
+
+const escapeXml = (value: string): string => value
+    .replaceAll("&", "&amp;")
+    .replaceAll("\"", "&quot;")
+    .replaceAll("'", "&apos;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+
+const getContent = async (entry: LocalizedEntry, locale: Language): Promise<{ slug: string }> => {
+    const loader = entry.i18n[locale] ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing ${locale} and English fallback`);
+    return loader();
+};
+
+export const prerender = true;
+
+export function getStaticPaths() {
+    return LANGUAGE_CODES.map((locale) => ({
+        params: { locale, vertical: "converters" },
+        props: { locale },
+    }));
+}
+
+const buildUrlEntry = async (locale: Language, path: string, index: number): Promise<string> => {
+    const links = await Promise.all(LANGUAGE_CODES.map(async (alternateLocale) => {
+        const alternateCategory = await getContent(convertersCategory, alternateLocale);
+        const alternateContent = index === 0 ? null : await getContent(ALL_ENTRIES[index - 1]!, alternateLocale);
+        const alternatePath = alternateContent
+            ? getUtilityPath(alternateLocale, alternateCategory.slug, alternateContent.slug)
+            : getCategoryPath(alternateLocale, alternateCategory.slug);
+        return `    <xhtml:link rel="alternate" hreflang="${alternateLocale}" href="${escapeXml(absoluteUrl(alternateLocale, alternatePath))}"/>`;
+    }));
+    return [
+        "  <url>",
+        `    <loc>${escapeXml(absoluteUrl(locale, path))}</loc>`,
+        ...links,
+        `    <changefreq>${index === 0 ? "weekly" : "monthly"}</changefreq>`,
+        `    <priority>${index === 0 ? "0.7" : "0.6"}</priority>`,
+        "  </url>",
+    ].join("\n");
+};
+
+export const GET: APIRoute = async ({ props }) => {
+    const locale = props.locale as Language;
+    const category = await getContent(convertersCategory, locale);
+    const contents = await Promise.all(ALL_ENTRIES.map((entry) => getContent(entry, locale)));
+    const paths = [
+        getCategoryPath(locale, category.slug),
+        ...contents.map((content) => getUtilityPath(locale, category.slug, content.slug)),
+    ];
+    const urls = await Promise.all(paths.map((path, index) => buildUrlEntry(locale, path, index)));
+
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">\n${urls.join("\n")}\n</urlset>`;
+    return new Response(xml, {
+        headers: {
+            "Content-Type": "application/xml; charset=utf-8",
+            "Cache-Control": "public, max-age=3600, s-maxage=3600, must-revalidate",
+        },
+    });
+};

package/src/pages/utilidades/[slug]/manifest.json.ts

@@ -0,0 +1,28 @@
+import type { APIRoute } from "astro";
+import { ALL_TOOLS, convertersCategory } from "../../../index";
+import type { ToolLocaleContent } from "../../../types";
+import { getUtilityPath } from "../../../mfe/routes";
+import { createUtilityManifestResponse, type UtilityManifestInput } from "../../../mfe/manifest";
+
+export async function getStaticPaths() {
+    const category = await convertersCategory.i18n.es!();
+    const paths = [];
+    for (const { entry } of ALL_TOOLS) {
+        const loader = entry.i18n.es ?? entry.i18n.en;
+        if (!loader) continue;
+        const content = await loader() as ToolLocaleContent;
+        const englishContent = await (entry.i18n.en ?? loader)() as ToolLocaleContent;
+        paths.push({
+            params: { slug: content.slug },
+            props: {
+                title: content.title,
+                description: content.description,
+                startUrl: getUtilityPath("es", category.slug, content.slug),
+                englishSlug: englishContent.slug,
+            },
+        });
+    }
+    return paths;
+}
+
+export const GET: APIRoute = ({ props }) => createUtilityManifestResponse(props as unknown as UtilityManifestInput);

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

@@ -0,0 +1,90 @@
+---
+import ProductionUtilityPage from "../../layouts/ProductionUtilityPage.astro";
+import { ALL_TOOLS, convertersCategory } 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 convertersCategory.i18n.es!();
+    const categories = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+        language,
+        await convertersCategory.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, convertersCategory } 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 convertersCategory.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 convertersCategory.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/diacritics_density.test.ts

@@ -96,7 +96,7 @@ describe('Diacritics density validation', () => {
           if (!loader) return;
 
           const content = await loader();
-          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const text = normalizeText(translatableContent(content as unknown as Record<string, unknown>));
           const rule = DIACRITIC_RULES[typedLocale];
           const letters = letterCount(text);
           const matches = diacriticCount(text, typedLocale);

package/src/tests/inverted_punctuation.test.ts

@@ -60,7 +60,7 @@ describe('Inverted punctuation validation', () => {
 
           const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
           const content = await loader();
-          const strings = translatableStrings(content as Record<string, unknown>);
+          const strings = translatableStrings(content as unknown as Record<string, unknown>);
           const missingQuestions = strings.flatMap((text) =>
             findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
           );

package/src/tests/mfe_cache_contract.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { getCacheControl, LONG_LIVED_ASSET_CACHE, SITEMAP_CACHE } from "../worker";
+
+describe("MFE cache contract", () => {
+    it("caches versioned assets and manifests for one year", () => {
+        expect(getCacheControl("/_utilities/converters/images/tool.webp")).toBe(LONG_LIVED_ASSET_CACHE);
+        expect(getCacheControl("/_utilities/converters/styles/tool.css")).toBe(LONG_LIVED_ASSET_CACHE);
+        expect(getCacheControl("/en/utilities/categories/converters/tool/manifest.json")).toBe(LONG_LIVED_ASSET_CACHE);
+    });
+
+    it("keeps sitemaps refreshable", () => {
+        expect(getCacheControl("/_utilities/en/converters/sitemap.xml")).toBe(SITEMAP_CACHE);
+    });
+});

package/src/tests/mfe_manifest.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { createUtilityManifestResponse } from "../mfe/manifest";
+
+describe("MFE utility manifest", () => {
+    it("returns a versioned installable manifest for the current utility", async () => {
+        const response = createUtilityManifestResponse({
+            title: "Card draw odds calculator",
+            description: "Calculate card draw probabilities.",
+            startUrl: "/en/utilities/categories/converters/card-draw-odds-calculator/",
+            englishSlug: "card-draw-odds-calculator",
+        });
+        const manifest = await response.json() as {
+            name: string;
+            start_url: string;
+            scope: string;
+            icons: { src: string; sizes: string; type: string; purpose: string }[];
+        };
+
+        expect(response.headers.get("Content-Type")).toContain("application/manifest+json");
+        expect(response.headers.get("Cache-Control")).toContain("immutable");
+        expect(manifest.name).toBe("Card draw odds calculator");
+        expect(manifest.start_url).toBe(manifest.scope);
+        expect(manifest.icons[0]?.src).toContain("/_utilities/converters/images/card-draw-odds-calculator.webp?version=");
+        expect(manifest.icons[0]?.sizes).toBe("512x512");
+        expect(manifest.icons[0]?.type).toBe("image/webp");
+        expect(manifest.icons[0]?.purpose).toBe("any");
+    });
+});

package/src/tests/registry_contract.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { ALL_ENTRIES } from '../entries';
+import { ALL_TOOLS } from '../tools';
+import type { ToolDefinition } from '../types';
+
+function isToolDefinition(value: unknown): value is ToolDefinition {
+  if (!value || typeof value !== 'object') return false;
+
+  const candidate = value as Record<string, unknown>;
+  return Boolean(
+    candidate.entry &&
+      typeof candidate.entry === 'object' &&
+      typeof candidate.Component === 'function' &&
+      typeof candidate.SEOComponent === 'function' &&
+      typeof candidate.BibliographyComponent === 'function',
+  );
+}
+
+const toolRoot = join(process.cwd(), 'src', 'tool');
+const toolDirectories = readdirSync(toolRoot, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory() && existsSync(join(toolRoot, entry.name, 'index.ts')))
+  .map((entry) => entry.name)
+  .sort();
+
+describe('Library registry contract', () => {
+  it('keeps ALL_ENTRIES and ALL_TOOLS synchronized by id', () => {
+    const entryIds = ALL_ENTRIES.map((entry) => entry.id);
+    const toolIds = ALL_TOOLS.map((tool) => tool.entry.id);
+
+    expect(new Set(entryIds).size).toBe(entryIds.length);
+    expect(new Set(toolIds).size).toBe(toolIds.length);
+    expect([...toolIds].sort()).toEqual([...entryIds].sort());
+  });
+
+  it('registers every tool runtime index in both public registries', async () => {
+    const failures: string[] = [];
+
+    for (const directory of toolDirectories) {
+      const runtimeModule = await import(
+        pathToFileURL(join(toolRoot, directory, 'index.ts')).href,
+      );
+      const definitions = [...new Set(Object.values(runtimeModule).filter(isToolDefinition))];
+
+      if (definitions.length !== 1) {
+        failures.push(`${directory}: expected exactly one ToolDefinition export, found ${definitions.length}`);
+        continue;
+      }
+
+      const [definition] = definitions;
+      if (!definition) {
+        failures.push(`${directory}: runtime definition is undefined`);
+        continue;
+      }
+      if (!ALL_TOOLS.some((tool) => tool.entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime definition is missing from ALL_TOOLS`);
+      }
+      if (!ALL_ENTRIES.some((entry) => entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime entry is missing from ALL_ENTRIES`);
+      }
+    }
+
+    expect(failures).toEqual([]);
+  });
+});

package/src/tests/script_density.test.ts

@@ -73,7 +73,7 @@ describe('Native script density validation', () => {
 
           const content = await loader();
           const rule = SCRIPT_RULES[typedLocale];
-          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const text = normalizeText(translatableContent(content as unknown as Record<string, unknown>));
           const letters = letterCount(text);
           const matches = scriptCount(text, typedLocale);
           const ratio = scriptRatio(text, typedLocale);

package/src/tests/seo_length.test.ts

@@ -11,6 +11,7 @@ describe('SEO Content Length Validation', () => {
       Object.keys(entry.i18n).forEach((locale) => {
         it(`${locale}: SEO section should exist`, async () => {
           const loader = (entry.i18n as Record<string, () => Promise<{ seo?: unknown[] }>>)[locale];
+          if (!loader) return;
           const content = await loader();
           if (!content.seo) return;
           expect(Array.isArray(content.seo)).toBe(true);

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/translation_copy.test.ts

@@ -106,8 +106,8 @@ describe('Locales must not copy another locale wholesale', () => {
 
       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 left = locales[leftIndex]!;
+          const right = locales[rightIndex]!;
           const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
 
           if (similarity >= COPY_THRESHOLD) {

package/src/tool/avifAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { avifAJpg } from './entry';
 export * from './entry';
 export const AVIF_A_JPG_TOOL: ToolDefinition = {

package/src/tool/avifAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { avifAPng } from './entry';
 export * from './entry';
 export const AVIF_A_PNG_TOOL: ToolDefinition = {

package/src/tool/avifAWebp/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { avifAWebp } from './entry';
 export * from './entry';
 export const AVIF_A_WEBP_TOOL: ToolDefinition = {

package/src/tool/bmpAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { bmpAJpg } from './entry';
 export * from './entry';
 export const BMP_A_JPG_TOOL: ToolDefinition = {

package/src/tool/bmpAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { bmpAPng } from './entry';
 export * from './entry';
 export const BMP_A_PNG_TOOL: ToolDefinition = {

package/src/tool/bmpAWebp/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { bmpAWebp } from './entry';
 export * from './entry';
 export const BMP_A_WEBP_TOOL: ToolDefinition = {

package/src/tool/gifAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { gifAJpg } from './entry';
 export * from './entry';
 export const GIF_A_JPG_TOOL: ToolDefinition = {

package/src/tool/gifAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { gifAPng } from './entry';
 export * from './entry';
 export const GIF_A_PNG_TOOL: ToolDefinition = {

package/src/tool/gifAWebp/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { gifAWebp } from './entry';
 export * from './entry';
 export const GIF_A_WEBP_TOOL: ToolDefinition = {

package/src/tool/jpgAIco/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { jpgAIco } from './entry';
 export * from './entry';
 export const JPG_A_ICO_TOOL: ToolDefinition = {

package/src/tool/jpgAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { jpgAPng } from './entry';
 export * from './entry';
 export const JPG_A_PNG_TOOL: ToolDefinition = {

package/src/tool/jpgAWebp/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { jpgAWebp } from './entry';
 export * from './entry';
 export const JPG_A_WEBP_TOOL: ToolDefinition = {

package/src/tool/pngAIco/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { pngAIco } from './entry';
 export * from './entry';
 export const PNG_A_ICO_TOOL: ToolDefinition = {

package/src/tool/pngAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { pngAJpg } from './entry';
 export * from './entry';
 export const PNG_A_JPG_TOOL: ToolDefinition = {

package/src/tool/pngAWebp/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { pngAWebp } from './entry';
 export * from './entry';
 export const PNG_A_WEBP_TOOL: ToolDefinition = {

package/src/tool/svgAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { svgAJpg } from './entry';
 export * from './entry';
 export const SVG_A_JPG_TOOL: ToolDefinition = {

package/src/tool/svgAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { svgAPng } from './entry';
 export * from './entry';
 export const SVG_A_PNG_TOOL: ToolDefinition = {

package/src/tool/webpAIco/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { webpAIco } from './entry';
 export * from './entry';
 export const WEBP_A_ICO_TOOL: ToolDefinition = {

package/src/tool/webpAJpg/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { webpAJpg } from './entry';
 export * from './entry';
 export const WEBP_A_JPG_TOOL: ToolDefinition = {

package/src/tool/webpAPng/index.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../../types';
 import { webpAPng } from './entry';
 export * from './entry';
 export const WEBP_A_PNG_TOOL: ToolDefinition = {

package/src/types.ts

@@ -1,12 +1,10 @@
 import type { SEOSection } from '@jjlmoya/utils-shared';
+import type { UtilityLocale } from '@jjlmoya/utils-shared/routing';
 import type { WithContext, Thing } from 'schema-dts';
 
 export type { SEOSection };
 
-export type KnownLocale =
-  | 'ar' | 'da' | 'de' | 'en' | 'es' | 'fi'
-  | 'fr' | 'it' | 'ja' | 'ko' | 'nb' | 'nl'
-  | 'pl' | 'pt' | 'ru' | 'sv' | 'tr' | 'zh';
+export type KnownLocale = UtilityLocale;
 
 export interface FAQItem {
   question: string;
@@ -23,7 +21,7 @@ export interface HowToStep {
   text: string;
 }
 
-export interface ToolLocaleContent<TUI extends Record<string, string> = Record<string, string>> {
+export interface ToolLocaleContent<TUI extends object = Record<string, string>> {
   slug: string;
   title: string;
   description: string;
@@ -46,7 +44,7 @@ export type LocaleLoader<T> = () => Promise<T>;
 
 export type LocaleMap<T> = Partial<Record<KnownLocale, LocaleLoader<T>>>;
 
-export interface ConvertersToolEntry<TUI extends Record<string, string> = Record<string, string>> {
+export interface ConvertersToolEntry<TUI extends object = Record<string, string>> {
   id: string;
   icons: {
     bg: string;

package/src/worker.ts

@@ -0,0 +1,27 @@
+interface UtilityMfeEnvironment {
+    ASSETS: { fetch(request: Request): Promise<Response> };
+}
+
+export const LONG_LIVED_ASSET_CACHE = "public, max-age=31536000, immutable";
+export const SITEMAP_CACHE = "public, max-age=3600, s-maxage=3600, must-revalidate";
+
+export const getCacheControl = (pathname: string): string | undefined => {
+    if (pathname.endsWith("/sitemap.xml")) return SITEMAP_CACHE;
+    if (pathname.endsWith("/manifest.json")) return LONG_LIVED_ASSET_CACHE;
+    if (pathname.startsWith("/_utilities/")) {
+        return LONG_LIVED_ASSET_CACHE;
+    }
+    return undefined;
+};
+
+export default {
+    async fetch(request: Request, environment: UtilityMfeEnvironment): Promise<Response> {
+        const response = await environment.ASSETS.fetch(request);
+        const cacheControl = getCacheControl(new URL(request.url).pathname);
+        if (!cacheControl) return response;
+
+        const headers = new Headers(response.headers);
+        headers.set("Cache-Control", cacheControl);
+        return new Response(response.body, { status: response.status, headers });
+    },
+};