@monkeyplus/flow 6.0.1 → 6.0.3

package/entry-server.mjs

@@ -1,5 +1,4 @@
 import { renderPageRequest } from './server/lib/handler.mjs';
-
 export default {
-  fetch: renderPageRequest,
-};
+    fetch: renderPageRequest,
+};

package/modules/sitemap/module.mjs

@@ -1,6 +1,230 @@
-import { resolve } from "node:path";
+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";
-import { resolvePackageFile, resolvePackagePath } from "../../src/public/shared.mjs";
+function createGeneratedSitemapHandler(siteUrl, locales) {
+  return `
+import pageDefinitions from 'virtual:flow/pages';
+
+const dynamicRouteCache = new Map();
+const configuredSiteUrl = ${JSON.stringify(siteUrl || "")};
+const enabledLocales = ${JSON.stringify(locales)};
+
+function escapeXml(value) {
+  return value
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function normalizePath(value) {
+  if (!value || value === '/') {
+    return '/';
+  }
+
+  return value.length > 1 && value.endsWith('/') ? value.slice(0, -1) : value;
+}
+
+function replacePath(pattern, url) {
+  let resolved = pattern;
+
+  if (typeof url === 'string') {
+    return normalizePath(resolved.replace('/**', '/' + url));
+  }
+
+  for (const [key, value] of Object.entries(url)) {
+    if (key === '_') {
+      continue;
+    }
+
+    resolved = resolved.replace(':' + key, value);
+  }
+
+  if (url._ && resolved.endsWith('/**')) {
+    resolved = resolved.replace('/**', '/' + url._);
+  }
+
+  return normalizePath(resolved.replaceAll('**', ''));
+}
+
+function toPublicRoutePattern(url) {
+  return normalizePath(url.replaceAll('*', ''));
+}
+
+function createLocale(code) {
+  const [lang = 'es', loc = 'ec'] = code.split('-');
+
+  return {
+    code,
+    lang,
+    loc,
+  };
+}
+
+async function getUrl(namePage, localeCode, options = {}) {
+  const enabledLocales = getEnabledLocaleCodes();
+  const targetLocale = localeCode || enabledLocales[0];
+
+  for (const definition of pageDefinitions) {
+    if (definition.name !== namePage) {
+      continue;
+    }
+
+    const localeEntries = targetLocale ? [targetLocale] : Object.keys(definition.locales);
+
+    for (const code of localeEntries) {
+      const localePage = definition.locales[code];
+
+      if (!localePage) {
+        continue;
+      }
+
+      if (options.url) {
+        return replacePath(localePage.url, options.url);
+      }
+
+      if (options.params) {
+        return replacePath(localePage.url, options.params);
+      }
+
+      if (localePage.dynamic && options.dynamicName) {
+        const locale = createLocale(code);
+        const ctx = createContext(definition, locale, localePage, localePage.url, {});
+        const entries = await getDynamicEntries(definition, code, ctx);
+        const entry = entries.find(candidate => candidate.name === options.dynamicName);
+
+        if (!entry) {
+          return undefined;
+        }
+
+        return replacePath(localePage.url, entry.url);
+      }
+
+      return toPublicRoutePattern(localePage.url);
+    }
+  }
+
+  return undefined;
+}
+
+async function getUrls(withLocale = false, omitNoPublish = false) {
+  const enabledLocales = getEnabledLocaleCodes();
+  const urls = [];
+
+  for (const definition of pageDefinitions) {
+    if (omitNoPublish && definition.noPublish) {
+      continue;
+    }
+
+    for (const [localeCode, localePage] of Object.entries(definition.locales)) {
+      if (enabledLocales.length && !enabledLocales.includes(localeCode)) {
+        continue;
+      }
+
+      if (localePage.dynamic) {
+        const locale = createLocale(localeCode);
+        const ctx = createContext(definition, locale, localePage, 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);
+        }
+
+        continue;
+      }
+
+      const url = toPublicRoutePattern(localePage.url);
+      urls.push(withLocale ? { url, locale: localeCode } : url);
+    }
+  }
+
+  return urls;
+}
+
+function getEnabledLocaleCodes() {
+  return enabledLocales;
+}
+
+function createContext(definition, locale, localePage, pathname, params, dynamic) {
+  return {
+    dynamic,
+    locale,
+    path: pathname,
+    name: definition.name,
+    page: localePage,
+    params,
+    view: definition.view,
+    utils: {
+      getLocale() {
+        return locale;
+      },
+      async getUrl(namePage, localeCode, options) {
+        return await getUrl(namePage, localeCode, options);
+      },
+      async getUrls(withLocale, omitNoPublish) {
+        return await getUrls(withLocale, omitNoPublish);
+      },
+    },
+  };
+}
+
+async function getDynamicEntries(definition, localeCode, ctx) {
+  const dynamic = ctx.page.dynamic;
+
+  if (!dynamic) {
+    return [];
+  }
+
+  const cacheKey = definition.name + ':' + localeCode + ':' + ctx.page.url;
+
+  if (dynamic.options?.once) {
+    const cached = dynamicRouteCache.get(cacheKey);
+
+    if (cached) {
+      return await cached;
+    }
+
+    const pending = Promise.resolve(dynamic.method(ctx));
+    dynamicRouteCache.set(cacheKey, pending);
+    return await pending;
+  }
+
+  return await dynamic.method(ctx);
+}
+
+export default async function sitemapHandler(event) {
+  const urls = await getUrls(true, true);
+  const requestUrl = event?.req?.url
+    ? 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>';
+
+  return new Response(xml, {
+    headers: {
+      'content-type': 'application/xml; charset=utf-8',
+    },
+  });
+}
+`;
+}
+function ensureGeneratedSitemapHandler(projectRoot, flowRuntimeConfig) {
+  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 : []
+  ), "utf8");
+  return handlerPath;
+}
 export default defineFlowModule({
   meta: {
     name: "sitemap",
@@ -11,8 +235,9 @@ 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 : resolvePackageFile("modules/sitemap/handler.ts", "modules/sitemap/handler.mjs", "modules/sitemap/handler.js");
+    const handlerPath = context.projectRoot === resolvePackagePath() ? localHandlerPath : ensureGeneratedSitemapHandler(context.projectRoot, contextRuntimeConfig);
     context.nitro.handlers.push({
       method: "get",
       route: options.route,

package/modules/strapi/runtime/client.mjs

@@ -54,8 +54,13 @@ async function getServerRuntimeConfig() {
   if (typeof window !== "undefined") {
     return void 0;
   }
-  const runtime = await import("nitro/runtime-config");
-  return runtime.useRuntimeConfig();
+  try {
+    const loadRuntimeModule = new Function("specifier", "return import(specifier);");
+    const runtime = await loadRuntimeModule("nitro/runtime-config");
+    return typeof runtime.useRuntimeConfig === "function" ? runtime.useRuntimeConfig() : void 0;
+  } catch {
+    return void 0;
+  }
 }
 async function getPublicStrapiConfig() {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "description": "@monkeyplus/flow package-first runtime with Vite, Nitro, Vue and a workspace playground.",
   "license": "MIT",
   "publishConfig": {

package/server/lib/pages.mjs

@@ -1,6 +1,16 @@
-import { useRuntimeConfig } from "nitro/runtime-config";
+import { createRequire } from "node:module";
 import pageDefinitions from "virtual:flow/pages";
 const dynamicRouteCache = /* @__PURE__ */ new Map();
+let runtimeConfigRequire;
+function getFlowRuntimeConfig() {
+  try {
+    runtimeConfigRequire ??= createRequire(import.meta.url);
+    const runtime = runtimeConfigRequire("nitro/runtime-config");
+    return typeof runtime.useRuntimeConfig === "function" ? runtime.useRuntimeConfig() : {};
+  } catch {
+    return {};
+  }
+}
 function normalizePath(value) {
   if (!value || value === "/") {
     return "/";
@@ -49,7 +59,7 @@ function matchPattern(pattern, pathname) {
   return offset === received.length ? params : null;
 }
 function createLocale(code) {
-  const config = useRuntimeConfig();
+  const config = getFlowRuntimeConfig();
   const defaults = config.flow?.locale;
   const [lang = defaults?.language || "es", loc = defaults?.location || "ec"] = code.split("-");
   return {
@@ -106,7 +116,7 @@ function combineName(name, dynamicName) {
   return `${name.replace(/\/*$/, "")}/${dynamicName.replace(/^\/*/, "")}`;
 }
 function getEnabledLocaleCodes() {
-  const runtimeConfig = useRuntimeConfig();
+  const runtimeConfig = getFlowRuntimeConfig();
   return runtimeConfig.flow?.locale?.locales || [];
 }
 async function getDynamicEntries(definition, localeCode, ctx) {
@@ -196,7 +206,7 @@ export async function getUrls(withLocale = false, omitNoPublish = false) {
   return urls;
 }
 export async function resolvePage(pathname) {
-  const runtimeConfig = useRuntimeConfig();
+  const runtimeConfig = getFlowRuntimeConfig();
   const enabledLocales = runtimeConfig.flow?.locale?.locales || [];
   const candidates = [];
   for (const definition of pageDefinitions) {
@@ -245,7 +255,7 @@ export async function resolvePage(pathname) {
   return void 0;
 }
 export async function resolvePageByName(name, pathname) {
-  const runtimeConfig = useRuntimeConfig();
+  const runtimeConfig = getFlowRuntimeConfig();
   const enabledLocales = runtimeConfig.flow?.locale?.locales || [];
   const definition = pageDefinitions.find((candidate) => candidate.name === name);
   if (!definition) {

package/server/renderer.d.ts

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

package/server/renderer.mjs

@@ -1,14 +1,36 @@
+let prerenderFetchHandlerPromise;
 function resolveRequest(input) {
   if (input instanceof Request) {
     return input;
   }
   return input?.req;
 }
-export default function renderPage(input) {
+async function resolvePrerenderFetchHandler() {
+  prerenderFetchHandlerPromise ||= (async () => {
+    try {
+      const ssrServiceUrl = new URL("../../vite/services/ssr/index.js", import.meta.url);
+      const ssrService = await import(
+        /* @vite-ignore */
+        ssrServiceUrl.href
+      );
+      const defaultService = ssrService.default;
+      const fetchHandler = defaultService?.fetch;
+      return typeof fetchHandler === "function" ? fetchHandler.bind(defaultService) : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  return await prerenderFetchHandlerPromise;
+}
+export default async function renderPage(input) {
   const viteEnvs = globalThis.__nitro_vite_envs__;
   const request = resolveRequest(input);
+  const viteFetchHandler = viteEnvs?.ssr?.fetch;
   if (!request) {
     return new Response("Not Found", { status: 404 });
   }
-  return viteEnvs?.ssr?.fetch(request);
+  if (typeof viteFetchHandler === "function") {
+    return viteFetchHandler(request);
+  }
+  return (await resolvePrerenderFetchHandler())?.(request);
 }

package/server.mjs

@@ -1,32 +1,30 @@
-interface ViteFetchEnv {
-  fetch(request: Request): Response | Promise<Response>;
+function isPageRequest(pathname) {
+    if (pathname.startsWith('/api/')) {
+        return false;
+    }
+    if (pathname.startsWith('/assets/')) {
+        return false;
+    }
+    return !/\.[a-z0-9]+$/i.test(pathname);
 }
-
-type FlowGlobalWithViteEnvs = typeof globalThis & {
-  __nitro_vite_envs__?: Record<string, ViteFetchEnv | undefined>;
-};
-
-function isPageRequest(pathname: string) {
-  if (pathname.startsWith('/api/')) {
-    return false;
-  }
-
-  if (pathname.startsWith('/assets/')) {
-    return false;
-  }
-
-  return !/\.[a-z0-9]+$/i.test(pathname);
+function resolveViteFetchHandler() {
+    const viteEnvs = Reflect.get(globalThis, '__nitro_vite_envs__');
+    if (!viteEnvs || typeof viteEnvs !== 'object') {
+        return undefined;
+    }
+    const ssrEnv = Reflect.get(viteEnvs, 'ssr');
+    if (!ssrEnv || typeof ssrEnv !== 'object') {
+        return undefined;
+    }
+    const fetchHandler = Reflect.get(ssrEnv, 'fetch');
+    return typeof fetchHandler === 'function' ? fetchHandler.bind(ssrEnv) : undefined;
 }
-
 export default {
-  async fetch(request: Request) {
-    const pathname = new URL(request.url).pathname;
-
-    if (!isPageRequest(pathname)) {
-      return;
-    }
-
-    const viteEnvs = (globalThis as FlowGlobalWithViteEnvs).__nitro_vite_envs__;
-    return viteEnvs?.ssr?.fetch(request);
-  },
-};
+    async fetch(request) {
+        const pathname = new URL(request.url).pathname;
+        if (!isPageRequest(pathname)) {
+            return;
+        }
+        return resolveViteFetchHandler()?.(request);
+    },
+};

package/src/public/nitro.mjs

@@ -17,6 +17,8 @@ export function createFlowNitroConfig(options = {}) {
   const flowModules = loadFlowModules(projectRoot, flowConfig);
   const flowNitroConfig = { ...flowConfig.nitro || {} };
   const flowNitroHooks = flowNitroConfig.hooks || {};
+  const configuredNoExternals = Array.isArray(flowNitroConfig.noExternals) ? flowNitroConfig.noExternals : [];
+  const flowPackagePattern = /^@monkeyplus\/flow(?:\/.*)?$/;
   const flowRuntimeConfig = typeof flowModules.nitro.runtimeConfig.flow === "object" && flowModules.nitro.runtimeConfig.flow ? flowModules.nitro.runtimeConfig.flow : {};
   const moduleRuntimeConfig = { ...flowModules.nitro.runtimeConfig };
   delete moduleRuntimeConfig.flow;
@@ -55,6 +57,7 @@ export function createFlowNitroConfig(options = {}) {
       existingHooks: flowNitroHooks
     }),
     plugins: flowModules.nitro.plugins,
+    noExternals: [...configuredNoExternals, flowPackagePattern],
     handlers: flowModules.nitro.handlers,
     routeRules: {
       "/api/**": { cors: true },

package/src/public/vite.mjs

@@ -1,11 +1,11 @@
 import { existsSync } from "node:fs";
 import { relative, resolve } from "node:path";
+import ui from "@nuxt/ui/vite";
 import Vue from "@vitejs/plugin-vue";
 import { nitro } from "nitro/vite";
-import { defineConfig, normalizePath } from "vite";
 import IconsResolver from "unplugin-icons/resolver";
 import Icons from "unplugin-icons/vite";
-import ui from "@nuxt/ui/vite";
+import { defineConfig, normalizePath } from "vite";
 import { resolveFlowConfig } from "../runtime/config.mjs";
 import { loadFlowModules } from "../runtime/modules.mjs";
 import { getPrerenderRoutes } from "../runtime/page-discovery.mjs";
@@ -208,6 +208,7 @@ export function createFlowViteConfig(options = {}) {
   const flowModules = loadFlowModules(projectRoot, flowConfig);
   const flowNitroConfig = { ...flowConfig.nitro || {} };
   const flowNitroHooks = flowNitroConfig.hooks || {};
+  const flowPackagePattern = /^@monkeyplus\/flow(?:\/.*)?$/;
   const userPrerenderRoutesHook = typeof flowNitroHooks["prerender:routes"] === "function" ? flowNitroHooks["prerender:routes"] : void 0;
   return defineConfig({
     plugins: [
@@ -232,7 +233,7 @@ export function createFlowViteConfig(options = {}) {
         ...flowNitroConfig,
         hooks: {
           ...flowNitroHooks,
-          async "prerender:routes"(routes) {
+          "prerender:routes": async function(routes) {
             const discoveredRoutes = await getPrerenderRoutes(projectRoot, flowConfig);
             for (const route of discoveredRoutes) {
               routes.add(route);
@@ -268,6 +269,9 @@ export function createFlowViteConfig(options = {}) {
         "@": resolve(projectRoot, "src"),
         ...flowModules.vite.resolve.alias
       }
+    },
+    ssr: {
+      noExternal: [flowPackagePattern]
     }
   });
 }

package/src/runtime/islands.mjs

@@ -1,7 +1,7 @@
+import islands from "virtual:flow/islands";
 import { createSSRApp } from "vue";
 import { getClientHead } from "./head.mjs";
 import { installFlowVuePlugins } from "./vue.mjs";
-import islands from "virtual:flow/islands";
 function parseIslandProps(value) {
   if (!value) {
     return {};

package/src/runtime/vue.d.ts

@@ -2,5 +2,5 @@ import type { App } from 'vue';
 interface DefaultPlugins {
     ui: boolean;
 }
-export declare function installFlowVuePlugins(app: App, {}?: DefaultPlugins): App<any>;
+export declare function installFlowVuePlugins(app: App, { ui: enableUi }?: DefaultPlugins): App<any>;
 export {};

package/src/runtime/vue.mjs

@@ -1,6 +1,7 @@
 import ui from "@nuxt/ui/vue-plugin";
-export function installFlowVuePlugins(app, {} = { ui: true }) {
-  if (ui)
+export function installFlowVuePlugins(app, { ui: enableUi } = { ui: true }) {
+  if (enableUi) {
     app.use(ui);
+  }
   return app;
 }