@monkeyplus/flow 6.0.6 → 6.0.8

package/modules/sitemap/module.mjs

@@ -2,13 +2,14 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { resolvePackagePath } from "../../src/public/shared.mjs";
 import { defineFlowModule } from "../../src/runtime/config.mjs";
-function createGeneratedSitemapHandler(siteUrl, locales) {
+function createGeneratedSitemapHandler(siteUrl, localeConfig) {
   return `
 import pageDefinitions from 'virtual:flow/pages';
 
 const dynamicRouteCache = new Map();
 const configuredSiteUrl = ${JSON.stringify(siteUrl || "")};
-const enabledLocales = ${JSON.stringify(locales)};
+const localeConfig = ${JSON.stringify(localeConfig)};
+const enabledLocales = localeConfig.locales;
 
 function escapeXml(value) {
   return value
@@ -27,6 +28,26 @@ function normalizePath(value) {
   return value.length > 1 && value.endsWith('/') ? value.slice(0, -1) : value;
 }
 
+function ensureLeadingSlash(value) {
+  if (!value) {
+    return '/';
+  }
+
+  return value.startsWith('/') ? value : '/' + value;
+}
+
+function ensureTrailingSlash(value) {
+  if (value === '/' || value.endsWith('/')) {
+    return value;
+  }
+
+  return value + '/';
+}
+
+function preserveTrailingSlash(value, source) {
+  return source.endsWith('/') ? ensureTrailingSlash(value) : value;
+}
+
 function replacePath(pattern, url) {
   let resolved = pattern;
 
@@ -53,8 +74,198 @@ function toPublicRoutePattern(url) {
   return normalizePath(url.replaceAll('*', ''));
 }
 
+function trimLeadingSlash(value) {
+  let result = value;
+
+  while (result.startsWith('/')) {
+    result = result.slice(1);
+  }
+
+  return result;
+}
+
+function trimTrailingSlash(value) {
+  let result = value;
+
+  while (result.endsWith('/')) {
+    result = result.slice(0, -1);
+  }
+
+  return result;
+}
+
+function combineName(name, dynamicName) {
+  return trimTrailingSlash(name) + '/' + trimLeadingSlash(dynamicName);
+}
+
+function getLanguage(locale) {
+  const [language = localeConfig.language || 'es'] = locale.split('-');
+  return language;
+}
+
+function getLocation(locale) {
+  const [, location = localeConfig.location || 'ec'] = locale.split('-');
+  return location;
+}
+
+function getDefaultLocaleCode() {
+  return localeConfig.language + '-' + localeConfig.location;
+}
+
+function routeHasPrefix(route, prefix) {
+  return route === prefix || route === prefix + '/' || route.startsWith(prefix + '/');
+}
+
+function getLocalePrefixVariants(localeCode) {
+  const lang = getLanguage(localeCode);
+  const loc = getLocation(localeCode);
+  const prefixes = new Set();
+
+  if (loc === localeConfig.location) {
+    prefixes.add('/' + lang);
+    return [...prefixes];
+  }
+
+  prefixes.add('/' + lang + '-' + loc);
+  prefixes.add('/' + lang + '/' + loc);
+
+  return [...prefixes];
+}
+
+function getLocalePrefix(localeCode) {
+  if (localeConfig.prefixStrategy === 'manual') {
+    return '';
+  }
+
+  if (localeCode === getDefaultLocaleCode()) {
+    return '';
+  }
+
+  const lang = getLanguage(localeCode);
+  const loc = getLocation(localeCode);
+
+  if (loc === localeConfig.location) {
+    return '/' + lang;
+  }
+
+  if (localeConfig.prefixFormat === 'nested') {
+    return '/' + lang + '/' + loc;
+  }
+
+  return '/' + lang + '-' + loc;
+}
+
+function localizeRoutePattern(localeCode, route) {
+  const normalizedRoute = ensureLeadingSlash(route || '/');
+  const prefix = getLocalePrefix(localeCode);
+
+  if (!prefix) {
+    return normalizedRoute;
+  }
+
+  if (getLocalePrefixVariants(localeCode).some(candidate => routeHasPrefix(normalizedRoute, candidate))) {
+    return normalizedRoute;
+  }
+
+  if (normalizedRoute === '/') {
+    return ensureTrailingSlash(prefix);
+  }
+
+  return preserveTrailingSlash(normalizePath(prefix) + normalizedRoute, normalizedRoute);
+}
+
+function toPublicRoute(localeCode, route) {
+  const localizedRoute = localizeRoutePattern(localeCode, route);
+  const publicRoute = localizedRoute.replaceAll('*', '');
+
+  return preserveTrailingSlash(normalizePath(publicRoute), localizedRoute);
+}
+
+function toAbsoluteUrl(origin, url) {
+  return new URL(url, origin).toString();
+}
+
+function buildAlternateLink(hreflang, origin, url) {
+  return '<xhtml:link rel="alternate" hreflang="' + escapeXml(hreflang) + '" href="' + escapeXml(toAbsoluteUrl(origin, url)) + '"/>';
+}
+
+function buildUrl(origin, url, lastMod, alternates = []) {
+  return [
+    '  <url>',
+    '    <loc>' + escapeXml(toAbsoluteUrl(origin, url)) + '</loc>',
+    '    <lastmod>' + escapeXml(lastMod) + '</lastmod>',
+    ...alternates.map(alternate => '    ' + alternate),
+    '  </url>',
+  ].join('\\n');
+}
+
+function groupByName(entries) {
+  const grouped = new Map();
+
+  for (const entry of entries) {
+    const group = grouped.get(entry.name) || [];
+    group.push(entry);
+    grouped.set(entry.name, group);
+  }
+
+  return [...grouped.values()];
+}
+
+function buildLocalizedUrls(entries, origin, lastMod) {
+  const defaultLocale = getDefaultLocaleCode();
+
+  return groupByName(entries).map((pages) => {
+    const pagesByLanguage = pages.reduce((result, page) => {
+      const language = getLanguage(page.locale);
+      const group = result.get(language) || [];
+      group.push(page);
+      result.set(language, group);
+      return result;
+    }, new Map());
+    const defaultEntry = pages.find(page => page.locale === defaultLocale) || pages[0];
+    const alternates = [buildAlternateLink('x-default', origin, defaultEntry.url)];
+
+    for (const [language, localizedPages] of [...pagesByLanguage.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+      const sortedPages = [...localizedPages].sort((left, right) => left.locale.localeCompare(right.locale));
+
+      if (sortedPages.length > 1) {
+        const languageDefault = sortedPages.find(page => getLocation(page.locale) === localeConfig.location) || sortedPages[0];
+        alternates.push(buildAlternateLink(language, origin, languageDefault.url));
+
+        for (const page of sortedPages) {
+          alternates.push(buildAlternateLink(page.locale, origin, page.url));
+        }
+
+        continue;
+      }
+
+      alternates.push(buildAlternateLink(language, origin, sortedPages[0].url));
+    }
+
+    return buildUrl(origin, defaultEntry.url, lastMod, alternates);
+  });
+}
+
+function buildSitemapXml(entries, origin) {
+  const normalizedEntries = entries
+    .map((entry) => typeof entry === 'string'
+      ? { url: entry, locale: localeConfig.language + '-' + localeConfig.location, name: entry }
+      : entry)
+    .sort((left, right) => left.url.localeCompare(right.url));
+  const lastMod = new Date().toISOString().split('T')[0];
+  const isMultiple = localeConfig.locales.length > 1;
+  const urls = isMultiple
+    ? buildLocalizedUrls(normalizedEntries, origin, lastMod)
+    : normalizedEntries.map(entry => buildUrl(origin, entry.url, lastMod));
+  const alternateNamespace = isMultiple
+    ? ' xmlns:xhtml="http://www.w3.org/1999/xhtml"'
+    : '';
+
+  return '<?xml version="1.0" encoding="UTF-8"?>\\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"' + alternateNamespace + '>\\n' + urls.join('\\n') + '\\n</urlset>';
+}
+
 function createLocale(code) {
-  const [lang = 'es', loc = 'ec'] = code.split('-');
+  const [lang = localeConfig.language || 'es', loc = localeConfig.location || 'ec'] = code.split('-');
 
   return {
     code,
@@ -91,7 +302,7 @@ async function getUrl(namePage, localeCode, options = {}) {
 
       if (localePage.dynamic && options.dynamicName) {
         const locale = createLocale(code);
-        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const ctx = createContext(definition, locale, localePage, toPublicRoute(code, localePage.url), {});
         const entries = await getDynamicEntries(definition, code, ctx);
         const entry = entries.find(candidate => candidate.name === options.dynamicName);
 
@@ -99,10 +310,10 @@ async function getUrl(namePage, localeCode, options = {}) {
           return undefined;
         }
 
-        return replacePath(localePage.url, entry.url);
+        return replacePath(localizeRoutePattern(code, localePage.url), entry.url);
       }
 
-      return toPublicRoutePattern(localePage.url);
+      return toPublicRoute(code, localePage.url);
     }
   }
 
@@ -125,19 +336,19 @@ async function getUrls(withLocale = false, omitNoPublish = false) {
 
       if (localePage.dynamic) {
         const locale = createLocale(localeCode);
-        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const ctx = createContext(definition, locale, localePage, toPublicRoute(localeCode, localePage.url), {});
         const entries = await getDynamicEntries(definition, localeCode, ctx);
 
         for (const entry of entries) {
-          const url = replacePath(localePage.url, entry.url);
-          urls.push(withLocale ? { url, locale: localeCode } : url);
+          const url = replacePath(localizeRoutePattern(localeCode, localePage.url), entry.url);
+          urls.push(withLocale ? { url, locale: localeCode, name: combineName(definition.name, entry.name) } : url);
         }
 
         continue;
       }
 
-      const url = toPublicRoutePattern(localePage.url);
-      urls.push(withLocale ? { url, locale: localeCode } : url);
+      const url = toPublicRoute(localeCode, localePage.url);
+      urls.push(withLocale ? { url, locale: localeCode, name: definition.name } : url);
     }
   }
 
@@ -201,12 +412,7 @@ export default async function sitemapHandler(event) {
     ? new URL(event.req.url, configuredSiteUrl || 'http://localhost')
     : new URL(configuredSiteUrl || 'http://localhost');
   const origin = configuredSiteUrl || requestUrl.origin;
-
-  const xml = '<?xml version="1.0" encoding="UTF-8"?>\\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\\n' + urls
-    .map((entry) => typeof entry === 'string'
-      ? '  <url><loc>' + escapeXml(new URL(entry, origin).toString()) + '</loc></url>'
-      : '  <url><loc>' + escapeXml(new URL(entry.url, origin).toString()) + '</loc><xhtml:link rel="alternate" hreflang="' + escapeXml(entry.locale) + '" href="' + escapeXml(new URL(entry.url, origin).toString()) + '" xmlns:xhtml="http://www.w3.org/1999/xhtml" /></url>')
-    .join('\\n') + '\\n</urlset>';
+  const xml = buildSitemapXml(urls, origin);
 
   return new Response(xml, {
     headers: {
@@ -216,12 +422,18 @@ export default async function sitemapHandler(event) {
 }
 `;
 }
-function ensureGeneratedSitemapHandler(projectRoot, flowRuntimeConfig) {
+function ensureGeneratedSitemapHandler(projectRoot, flowConfig) {
   const handlerPath = resolve(projectRoot, ".flow/generated/modules/sitemap/handler.mjs");
   mkdirSync(dirname(handlerPath), { recursive: true });
   writeFileSync(handlerPath, createGeneratedSitemapHandler(
-    typeof flowRuntimeConfig.siteUrl === "string" ? flowRuntimeConfig.siteUrl : void 0,
-    Array.isArray(flowRuntimeConfig.locale?.locales) ? flowRuntimeConfig.locale.locales : []
+    typeof flowConfig.siteUrl === "string" ? flowConfig.siteUrl : void 0,
+    {
+      locales: Array.isArray(flowConfig.locale?.locales) ? flowConfig.locale.locales : ["es-ec"],
+      language: typeof flowConfig.locale?.language === "string" ? flowConfig.locale.language : "es",
+      location: typeof flowConfig.locale?.location === "string" ? flowConfig.locale.location : "ec",
+      prefixStrategy: flowConfig.locale?.prefixStrategy === "manual" ? "manual" : "auto",
+      prefixFormat: flowConfig.locale?.prefixFormat === "nested" ? "nested" : "compact"
+    }
   ), "utf8");
   return handlerPath;
 }
@@ -235,9 +447,11 @@ export default defineFlowModule({
     prerender: true
   },
   setup(options, context) {
-    const contextRuntimeConfig = typeof context.nitro.runtimeConfig.flow === "object" && context.nitro.runtimeConfig.flow ? context.nitro.runtimeConfig.flow : {};
     const localHandlerPath = resolve(context.projectRoot, "modules/sitemap/handler.ts");
-    const handlerPath = context.projectRoot === resolvePackagePath() ? localHandlerPath : ensureGeneratedSitemapHandler(context.projectRoot, contextRuntimeConfig);
+    const handlerPath = context.projectRoot === resolvePackagePath() ? localHandlerPath : ensureGeneratedSitemapHandler(context.projectRoot, {
+      siteUrl: context.flowConfig.siteUrl,
+      locale: context.flowConfig.locale
+    });
     context.nitro.handlers.push({
       method: "get",
       route: options.route,

package/modules/sitemap/xml.d.ts

@@ -0,0 +1,7 @@
+import type { PageUrlInfo } from '../../src/runtime/pages.ts';
+export interface SitemapLocaleConfig {
+    locales: string[];
+    language: string;
+    location: string;
+}
+export declare function buildSitemapXml(entries: Array<string | PageUrlInfo>, origin: string, locale: SitemapLocaleConfig): string;

package/modules/sitemap/xml.mjs

@@ -0,0 +1,87 @@
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function getLanguage(locale) {
+  const [language = "es"] = locale.split("-");
+  return language;
+}
+function getLocation(locale) {
+  const [, location = "ec"] = locale.split("-");
+  return location;
+}
+function toAbsoluteUrl(origin, url) {
+  return new URL(url, origin).toString();
+}
+function buildAlternateLink(hreflang, origin, url) {
+  return `<xhtml:link rel="alternate" hreflang="${escapeXml(hreflang)}" href="${escapeXml(toAbsoluteUrl(origin, url))}"/>`;
+}
+function buildUrl(origin, url, lastMod, alternates = []) {
+  const lines = [
+    "  <url>",
+    `    <loc>${escapeXml(toAbsoluteUrl(origin, url))}</loc>`,
+    `    <lastmod>${escapeXml(lastMod)}</lastmod>`,
+    ...alternates.map((alternate) => `    ${alternate}`),
+    "  </url>"
+  ];
+  return lines.join("\n");
+}
+function normalizeEntries(entries, locale) {
+  const defaultLocale = `${locale.language}-${locale.location}`;
+  return entries.map((entry) => {
+    if (typeof entry === "string") {
+      return {
+        url: entry,
+        locale: defaultLocale,
+        name: entry
+      };
+    }
+    return entry;
+  }).sort((left, right) => left.url.localeCompare(right.url));
+}
+function groupByName(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const group = grouped.get(entry.name) || [];
+    group.push(entry);
+    grouped.set(entry.name, group);
+  }
+  return [...grouped.values()];
+}
+function buildLocalizedUrls(entries, origin, locale, lastMod) {
+  const defaultLocale = `${locale.language}-${locale.location}`;
+  return groupByName(entries).map((pages) => {
+    const pagesByLanguage = pages.reduce((result, page) => {
+      const language = getLanguage(page.locale);
+      const group = result.get(language) || [];
+      group.push(page);
+      result.set(language, group);
+      return result;
+    }, /* @__PURE__ */ new Map());
+    const defaultEntry = pages.find((page) => page.locale === defaultLocale) || pages[0];
+    const alternates = [buildAlternateLink("x-default", origin, defaultEntry.url)];
+    for (const [language, localizedPages] of [...pagesByLanguage.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+      const sortedPages = [...localizedPages].sort((left, right) => left.locale.localeCompare(right.locale));
+      if (sortedPages.length > 1) {
+        const languageDefault = sortedPages.find((page) => getLocation(page.locale) === locale.location) || sortedPages[0];
+        alternates.push(buildAlternateLink(language, origin, languageDefault.url));
+        for (const page of sortedPages) {
+          alternates.push(buildAlternateLink(page.locale, origin, page.url));
+        }
+        continue;
+      }
+      alternates.push(buildAlternateLink(language, origin, sortedPages[0].url));
+    }
+    return buildUrl(origin, defaultEntry.url, lastMod, alternates);
+  });
+}
+export function buildSitemapXml(entries, origin, locale) {
+  const normalizedEntries = normalizeEntries(entries, locale);
+  const lastMod = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const isMultiple = locale.locales.length > 1;
+  const urls = isMultiple ? buildLocalizedUrls(normalizedEntries, origin, locale, lastMod) : normalizedEntries.map((entry) => buildUrl(origin, entry.url, lastMod));
+  const alternateNamespace = isMultiple ? ' xmlns:xhtml="http://www.w3.org/1999/xhtml"' : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${alternateNamespace}>
+${urls.join("\n")}
+</urlset>`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "6.0.6",
+  "version": "6.0.8",
   "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
   "publishConfig": {
@@ -40,6 +40,10 @@
       "types": "./modules/strapi/runtime/client.d.ts",
       "import": "./modules/strapi/runtime/client.mjs"
     },
+    "./modules/images": {
+      "types": "./src/public/modules/images.d.ts",
+      "import": "./src/public/modules/images.mjs"
+    },
     "./modules/sitemap": {
       "types": "./src/public/modules/sitemap.d.ts",
       "import": "./src/public/modules/sitemap.mjs"
@@ -72,8 +76,10 @@
     "@unhead/vue": "^3.1.0",
     "@vitejs/plugin-vue": "^6.0.5",
     "@vue/server-renderer": "^3.5.13",
+    "ipx": "^3.1.1",
     "nitro": "3.0.260429-beta",
     "std-env": "^4.0.0",
+    "ufo": "^1.6.1",
     "unhead": "^3.1.0",
     "unplugin-icons": "^23.0.1",
     "vite": "^8.0.5",

package/server/lib/pages.mjs

@@ -1,5 +1,7 @@
 import { createRequire } from "node:module";
 import pageDefinitions from "virtual:flow/pages";
+import { getFlowImageRuntimeUtils } from "../../modules/images/runtime/server.mjs";
+import { localizeRoutePattern, normalizePath, toPublicRoute } from "../../src/runtime/locale-routing.mjs";
 const dynamicRouteCache = /* @__PURE__ */ new Map();
 let runtimeConfigRequire;
 function getFlowRuntimeConfig() {
@@ -11,12 +13,6 @@ function getFlowRuntimeConfig() {
     return {};
   }
 }
-function normalizePath(value) {
-  if (!value || value === "/") {
-    return "/";
-  }
-  return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
-}
 function scorePattern(pattern) {
   return normalizePath(pattern).split("/").filter(Boolean).reduce((score, segment) => {
     if (segment === "**") {
@@ -69,6 +65,7 @@ function createLocale(code) {
   };
 }
 function createContext(definition, locale, localePage, pathname, params, dynamic) {
+  const imageUtils = getFlowImageRuntimeUtils();
   return {
     dynamic,
     locale,
@@ -82,11 +79,12 @@ function createContext(definition, locale, localePage, pathname, params, dynamic
         return locale;
       },
       async getUrl(namePage, localeCode, options) {
-        return await getUrl(namePage, localeCode, options);
+        return await getUrl(namePage, localeCode || locale.code, options);
       },
       async getUrls(withLocale, omitNoPublish) {
         return await getUrls(withLocale, omitNoPublish);
-      }
+      },
+      ...imageUtils || {}
     }
   };
 }
@@ -109,9 +107,6 @@ function replacePath(pattern, url) {
   }
   return normalizePath(resolved.replaceAll("**", ""));
 }
-function toPublicRoutePattern(url) {
-  return normalizePath(url.replaceAll("*", ""));
-}
 function combineName(name, dynamicName) {
   return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
 }
@@ -147,6 +142,7 @@ async function resolveDynamicEntry(definition, localeCode, localePage, ctx, path
 export async function getUrl(namePage, localeCode, options = {}) {
   const enabledLocales = getEnabledLocaleCodes();
   const targetLocale = localeCode || enabledLocales[0];
+  const runtimeConfig = getFlowRuntimeConfig();
   for (const definition of pageDefinitions) {
     if (definition.name !== namePage) {
       continue;
@@ -154,32 +150,34 @@ export async function getUrl(namePage, localeCode, options = {}) {
     const localeEntries = targetLocale ? [targetLocale] : Object.keys(definition.locales);
     for (const code of localeEntries) {
       const localePage = definition.locales[code];
+      const localizedRoute = localizeRoutePattern(runtimeConfig.flow, code, localePage?.url || "/");
       if (!localePage) {
         continue;
       }
       if (options.url) {
-        return replacePath(localePage.url, options.url);
+        return replacePath(localizedRoute, options.url);
       }
       if (options.params) {
-        return replacePath(localePage.url, options.params);
+        return replacePath(localizedRoute, options.params);
       }
       if (localePage.dynamic && options.dynamicName) {
         const locale = createLocale(code);
-        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const ctx = createContext(definition, locale, localePage, toPublicRoute(runtimeConfig.flow, code, localePage.url), {});
         const entries = await getDynamicEntries(definition, code, ctx);
         const entry = entries.find((candidate) => candidate.name === options.dynamicName);
         if (!entry) {
           return void 0;
         }
-        return replacePath(localePage.url, entry.url);
+        return replacePath(localizedRoute, entry.url);
       }
-      return toPublicRoutePattern(localePage.url);
+      return toPublicRoute(runtimeConfig.flow, code, localePage.url);
     }
   }
   return void 0;
 }
 export async function getUrls(withLocale = false, omitNoPublish = false) {
   const enabledLocales = getEnabledLocaleCodes();
+  const runtimeConfig = getFlowRuntimeConfig();
   const urls = [];
   for (const definition of pageDefinitions) {
     if (omitNoPublish && definition.noPublish) {
@@ -191,15 +189,15 @@ export async function getUrls(withLocale = false, omitNoPublish = false) {
       }
       if (localePage.dynamic) {
         const locale = createLocale(localeCode);
-        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const ctx = createContext(definition, locale, localePage, toPublicRoute(runtimeConfig.flow, localeCode, localePage.url), {});
         const entries = await getDynamicEntries(definition, localeCode, ctx);
         for (const entry of entries) {
-          const url2 = replacePath(localePage.url, entry.url);
+          const url2 = replacePath(localizeRoutePattern(runtimeConfig.flow, localeCode, localePage.url), entry.url);
           urls.push(withLocale ? { url: url2, locale: localeCode, name: combineName(definition.name, entry.name) } : url2);
         }
         continue;
       }
-      const url = toPublicRoutePattern(localePage.url);
+      const url = toPublicRoute(runtimeConfig.flow, localeCode, localePage.url);
       urls.push(withLocale ? { url, locale: localeCode, name: definition.name } : url);
     }
   }
@@ -214,14 +212,15 @@ export async function resolvePage(pathname) {
       if (enabledLocales.length && !enabledLocales.includes(localeCode)) {
         continue;
       }
-      const params = matchPattern(localePage.url, pathname);
+      const localizedRoute = localizeRoutePattern(runtimeConfig.flow, localeCode, localePage.url);
+      const params = matchPattern(localizedRoute, pathname);
       if (params) {
         candidates.push({
           definition,
           localeCode,
           localePage,
           params,
-          score: scorePattern(localePage.url)
+          score: scorePattern(localizedRoute)
         });
       }
     }

package/server/lib/render.mjs

@@ -5,7 +5,9 @@ import bases from "virtual:flow/bases";
 import layouts from "virtual:flow/layouts";
 import templates from "virtual:flow/templates";
 import { createSSRApp, defineComponent, h } from "vue";
+import { getFlowImageRuntimeUtils } from "../../modules/images/runtime/server.mjs";
 import { installFlowVuePlugins } from "../../src/runtime/vue";
+import { getUrl, getUrls } from "./pages.mjs";
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
@@ -104,6 +106,19 @@ async function renderBody(page) {
     params: page.params,
     path: page.pathname
   };
+  const imageUtils = getFlowImageRuntimeUtils();
+  const utils = {
+    getLocale() {
+      return page.locale;
+    },
+    async getUrl(namePage, localeCode, options) {
+      return await getUrl(namePage, localeCode || page.locale.code, options);
+    },
+    async getUrls(withLocale, omitNoPublish) {
+      return await getUrls(withLocale, omitNoPublish);
+    },
+    ...imageUtils || {}
+  };
   const TemplateRoot = defineComponent({
     render() {
       const viewNode = h(TemplateComponent, context);
@@ -117,6 +132,7 @@ async function renderBody(page) {
   });
   const app = createSSRApp(TemplateRoot);
   app.provide("context", context);
+  app.provide("utils", utils);
   const head = createHead();
   head.push(normalizeSeoToHead(page.head, fallbackTitle, fallbackDescription));
   app.use(head);

package/server/renderer.d.ts

@@ -1,3 +1,3 @@
 export default function renderPage(input: Request | {
     req?: Request;
-}): Promise<Response | undefined>;
+}): Promise<any>;

package/server/renderer.mjs

@@ -38,7 +38,8 @@ async function resolvePrerenderFetchHandler() {
 export default async function renderPage(input) {
   const viteEnvs = globalThis.__nitro_vite_envs__;
   const request = resolveRequest(input);
-  const viteFetchHandler = viteEnvs?.ssr?.fetch;
+  const viteEnv = viteEnvs?.ssr;
+  const viteFetchHandler = typeof viteEnv?.fetch === "function" ? viteEnv.fetch.bind(viteEnv) : void 0;
   if (!request) {
     return new Response("Not Found", { status: 404 });
   }

package/src/public/components.d.ts

@@ -1 +1,4 @@
 export { default as FlowIsland } from '../runtime/components/FlowIsland.ts';
+export { default as MkImage } from '../runtime/components/MkImage.ts';
+export { default as MkLink } from '../runtime/components/MkLink.ts';
+export { default as MkPicture } from '../runtime/components/MkPicture.ts';

package/src/public/components.mjs

@@ -1 +1,4 @@
 export { default as FlowIsland } from "../runtime/components/FlowIsland.mjs";
+export { default as MkImage } from "../runtime/components/MkImage.mjs";
+export { default as MkLink } from "../runtime/components/MkLink.mjs";
+export { default as MkPicture } from "../runtime/components/MkPicture.mjs";