@monkeyplus/flow 5.0.0-rc.1 → 5.0.0-rc.100

package/dist/chunks/vite-node.mjs

@@ -0,0 +1,154 @@
+import { pathToFileURL } from 'node:url';
+import { createApp, defineEventHandler, defineLazyEventHandler, createError } from 'h3';
+import { ViteNodeServer } from 'vite-node/server';
+import fse from 'fs-extra';
+import { resolve as resolve$1 } from 'pathe';
+import { addServerMiddleware } from '@monkeyplus/flow-kit';
+import { normalizeViteManifest } from 'vue-bundle-renderer';
+import { resolve } from 'mlly';
+import { d as distDir } from './index.mjs';
+import { c as createIsExternal, i as isCSS } from './external.mjs';
+import 'hookable';
+import 'url';
+import 'unimport';
+import 'unplugin';
+import 'ufo';
+import 'fs';
+import 'escape-string-regexp';
+import 'scule';
+import 'knitwork';
+import 'node:fs';
+import 'nitropack';
+import 'defu';
+import 'node:module';
+import 'chokidar';
+import 'perfect-debounce';
+import 'untyped';
+import 'vite';
+import '@rollup/plugin-replace';
+import 'pkg-types';
+import 'ohash';
+import 'externality';
+
+function viteNodePlugin(ctx) {
+  const invalidates = /* @__PURE__ */ new Set();
+  return {
+    name: "nuxt:vite-node-server",
+    enforce: "post",
+    configureServer(server) {
+      server.middlewares.use("/__nuxt_vite_node__", createViteNodeMiddleware(ctx, invalidates));
+    },
+    handleHotUpdate({ file, server }) {
+      function markInvalidate(mod) {
+        if (invalidates.has(mod.id))
+          return;
+        invalidates.add(mod.id);
+        for (const importer of mod.importers)
+          markInvalidate(importer);
+      }
+      const mods = server.moduleGraph.getModulesByFile(file) || [];
+      for (const mod of mods)
+        markInvalidate(mod);
+    }
+  };
+}
+function registerViteNodeMiddleware(ctx) {
+  addServerMiddleware({
+    route: "/__nuxt_vite_node__/",
+    handler: createViteNodeMiddleware(ctx)
+  });
+}
+function getManifest(ctx) {
+  const css = Array.from(ctx.ssrServer.moduleGraph.urlToModuleMap.keys()).filter((i) => isCSS(i));
+  const manifest = normalizeViteManifest({
+    "@vite/client": {
+      file: "@vite/client",
+      css,
+      module: true,
+      isEntry: true
+    },
+    [ctx.entry]: {
+      file: ctx.entry,
+      isEntry: true,
+      module: true,
+      resourceType: "script"
+    }
+  });
+  return manifest;
+}
+function createViteNodeMiddleware(ctx, invalidates = /* @__PURE__ */ new Set()) {
+  const app = createApp();
+  app.use("/manifest", defineEventHandler(() => {
+    const manifest = getManifest(ctx);
+    return manifest;
+  }));
+  app.use("/invalidates", defineEventHandler(() => {
+    if (invalidates.size) {
+      for (const key of ctx.ssrServer.moduleGraph.fileToModulesMap.keys()) {
+        if (key.startsWith(`${ctx.nuxt.options.appDir}/entry`))
+          invalidates.add(key);
+      }
+    }
+    const ids = Array.from(invalidates);
+    invalidates.clear();
+    return ids;
+  }));
+  app.use("/module", defineLazyEventHandler(() => {
+    const viteServer = ctx.ssrServer;
+    const node = new ViteNodeServer(viteServer, {
+      deps: {
+        inline: [
+          /\/(nuxt|nuxt3)\//,
+          /^#/,
+          ...ctx.nuxt.options.build.transpile
+        ]
+      },
+      transformMode: {
+        ssr: [/.*/],
+        web: []
+      }
+    });
+    const isExternal = createIsExternal(viteServer, ctx.nuxt.options.rootDir);
+    node.shouldExternalize = async (id) => {
+      const result = await isExternal(id);
+      if (result?.external)
+        return resolve(result.id, { url: ctx.nuxt.options.rootDir });
+      return false;
+    };
+    return async (event) => {
+      const moduleId = decodeURI(event.req.url).substring(1);
+      if (moduleId === "/")
+        throw createError({ statusCode: 400 });
+      const module = await node.fetchModule(moduleId);
+      return module;
+    };
+  }));
+  return app.nodeHandler;
+}
+async function initViteNodeServer(ctx) {
+  let entryPath = resolve$1(ctx.nuxt.options.appDir, "entry.async.mjs");
+  if (!fse.existsSync(entryPath))
+    entryPath = resolve$1(ctx.nuxt.options.appDir, "entry.async.ts");
+  const host = ctx.nuxt.options.server.host || "localhost";
+  const port = ctx.nuxt.options.server.port || "3000";
+  const protocol = ctx.nuxt.options.server.https ? "https" : "http";
+  const viteNodeServerOptions = {
+    baseURL: `${protocol}://${host}:${port}/__nuxt_vite_node__`,
+    root: ctx.nuxt.options.srcDir,
+    entryPath,
+    base: ctx.ssrServer.config.base || "/_nuxt/"
+  };
+  process.env.NUXT_VITE_NODE_OPTIONS = JSON.stringify(viteNodeServerOptions);
+  const serverResolvedPath = resolve$1(distDir, "core/runtime/vite-node.mjs");
+  const manifestResolvedPath = resolve$1(distDir, "core/runtime/client.manifest.mjs");
+  await fse.writeFile(
+    resolve$1(ctx.nuxt.options.buildDir, "dist/server/server.mjs"),
+    `export { default } from ${JSON.stringify(pathToFileURL(serverResolvedPath).href)}`
+  );
+  await fse.writeFile(
+    resolve$1(ctx.nuxt.options.buildDir, "dist/server/client.manifest.mjs"),
+    `export { default } from ${JSON.stringify(pathToFileURL(manifestResolvedPath).href)}`
+  );
+}
+
+export { initViteNodeServer, registerViteNodeMiddleware, viteNodePlugin };

package/dist/core/runtime/client.manifest.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<any>;
+export default _default;

package/dist/core/runtime/client.manifest.mjs

@@ -0,0 +1,6 @@
+import { $fetch } from 'ohmyfetch';
+import { getViteNodeOptions } from './vite-node-shared.mjs';
+
+const viteNodeOptions = getViteNodeOptions();
+
+export default () => $fetch('/manifest', { baseURL: viteNodeOptions.baseURL });

package/dist/core/runtime/nitro/flow.mjs

@@ -1,6 +1,6 @@
-import { defineEventHandler } from "h3";
 import "node-fetch-native/polyfill";
-import { useRuntimeConfig } from "#internal/nitro";
+import { defineEventHandler } from "h3";
+import { defineCachedFunction, useRuntimeConfig } from "#internal/nitro";
 const getServerApp = cachedImport(() => import("#server"));
 const getFlowRenderer = cachedResult(async () => {
   const createFlowApp = await getServerApp();
@@ -12,6 +12,7 @@ export default defineEventHandler(async ({ context }) => {
   const flow = await getFlowRenderer();
   context.flow = flow;
   context.render = flow.render;
+  context.defineCachedFunction = defineCachedFunction;
 });
 function _interopDefault(e) {
   return e && typeof e === "object" && "default" in e ? e.default : e;

package/dist/core/runtime/nitro/renderer.mjs

@@ -1,4 +1,10 @@
 import { eventHandler, useQuery } from "h3";
+import { joinURL } from "ufo";
+const normalizeCall = async (seo, ctx) => {
+  if (typeof seo === "function")
+    return await seo(ctx);
+  return seo || {};
+};
 export default eventHandler(async (event) => {
   const url = event.req.url?.split("?")[0];
   const flow = event.context.flow;
@@ -9,48 +15,84 @@ export default eventHandler(async (event) => {
   const scripts = { head: [], bodyStart: [], bodyEnd: [] };
   const chunks = { head: [], body: [] };
   const generate = {};
-  const { page, locale, params, view } = flow.router.byUrl.lookup(url) || {};
+  const { page, locale, params, view, name: pageName } = flow.router.byUrl.lookup(url) || {};
   if (!page)
     return;
-  await flow.callHook("page:scripts", scripts);
   if (view.bundle)
     await flow.callHook("page:chunks", view.bundle, chunks);
   const templateContext = {};
-  const dynamyc = params?._;
-  const contextPage = {};
-  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  const dynamic = params?._;
+  const contextPage = {
+    chunks,
+    locale
+  };
+  const contextInject = {};
+  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value, defineCachedFunction: event.context.defineCachedFunction }, flow.app.utils);
+  const contextHooks = {};
+  await flow.callHook("page:context", { localeCode: locale.code, page: pageName }, utils, contextHooks);
   templateContext.url = url;
+  templateContext.baseURL = flow.$config.app.baseURL;
+  const pageObject = {
+    name: pageName,
+    pathname: url,
+    url: joinURL(flow.site.origin, templateContext.baseURL, `${url}`),
+    origin: flow.site.origin,
+    joinOrigin: (_url, includeBase) => joinURL(flow.site.origin, includeBase ? templateContext.baseURL : "/", _url)
+  };
+  templateContext.page = pageObject;
+  contextPage.page = pageObject;
   templateContext.locale = locale;
   templateContext.view = view;
-  if (dynamyc && page.dynamic) {
+  if (dynamic && page.dynamic) {
     const pages = await page.dynamic.method({ locale, utils });
-    const dynamicPage = pages.find((_page) => _page.url === dynamyc);
+    const dynamicPage = pages.find((_page) => _page.url === dynamic);
     if (!dynamicPage)
       return;
     if (page.dynamic.assign)
       templateContext[page.dynamic.assign] = dynamicPage.context;
-    contextPage.dynamyc = dynamicPage;
+    contextPage.dynamic = dynamicPage;
   }
   templateContext.seo = {};
-  templateContext.context = {};
-  templateContext.sharedContext = {};
+  const sharedContext = await utils.getSharedContext({
+    ...contextHooks,
+    ...contextPage,
+    utils
+  });
+  templateContext.sharedContext = sharedContext || {};
   templateContext.utils = utils;
-  templateContext.seo = await page.seo?.({ ...contextPage, utils }) || {};
-  templateContext.context = await page.context?.({ ...contextPage, utils }) || {};
+  templateContext.seo = await normalizeCall(page?.seo, { ...contextHooks, ...contextPage, utils, sharedContext });
+  const contexData = await page.context?.({ ...contextHooks, ...contextPage, utils, sharedContext }) || {};
+  templateContext.context = {
+    ...contextHooks,
+    ...contexData
+  };
+  await flow.callHook("page:scripts", scripts, templateContext);
   templateContext.getHeadScripts = () => {
     return scripts.head.join("\n");
   };
+  templateContext.getBodyEndScripts = () => {
+    return scripts.bodyEnd.join("\n");
+  };
   templateContext.getHeadChunks = () => {
     return chunks.head.join("\n");
   };
   templateContext.getBodyChunks = () => {
     return chunks.body.join("\n");
   };
+  templateContext.getInjectContext = () => {
+    return `<script id="__FLOW_DATA__" type="application/json">${JSON.stringify(contextInject)}<\/script>`;
+  };
   const query = useQuery(event);
   if (query?.context)
     return { ...templateContext, utils: Object.keys(utils) };
-  const html = await flow.render(view, templateContext);
-  event.res.setHeader("Content-Type", "text/html;charset=UTF-8");
+  let html;
+  if (view.render)
+    html = await view.render(templateContext, event);
+  else
+    html = await flow.render(view, templateContext);
+  event.res.setHeader("Content-Type", view.contentType || "text/html;charset=UTF-8");
+  if (view.postRender)
+    html = await view.postRender(html, event);
   if (flow.generate) {
     await flow.callHook("page:generate", generate);
     globalThis.generate = generate;

package/dist/core/runtime/vite-node-shared.d.mts

@@ -0,0 +1 @@
+export function getViteNodeOptions(): any;

package/dist/core/runtime/vite-node-shared.d.ts

@@ -0,0 +1,8 @@
+export interface ViteNodeRuntimeOptions {
+  baseURL: string
+  rootDir: string
+  entryPath: string
+  base: string
+}
+
+export function getViteNodeOptions (): ViteNodeRuntimeOptions;

package/dist/core/runtime/vite-node-shared.mjs

@@ -0,0 +1,3 @@
+export function getViteNodeOptions() {
+  return JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS || '{}');
+}

package/dist/core/runtime/vite-node.d.mts

@@ -0,0 +1,2 @@
+declare function _default(ssrContext: any): Promise<any>;
+export default _default;

package/dist/core/runtime/vite-node.mjs

@@ -0,0 +1,42 @@
+import { performance } from 'node:perf_hooks';
+import { ViteNodeRunner } from 'vite-node/client';
+import { $fetch } from 'ohmyfetch';
+import consola from 'consola';
+import { getViteNodeOptions } from './vite-node-shared.mjs';
+
+const viteNodeOptions = getViteNodeOptions();
+console.log(viteNodeOptions);
+const runner = new ViteNodeRunner({
+  root: viteNodeOptions.root, // Equals to Nuxt `srcDir`
+  base: viteNodeOptions.base,
+  async fetchModule(id) {
+    return await $fetch(`/module/${encodeURI(id)}`, {
+      baseURL: viteNodeOptions.baseURL,
+    });
+  },
+});
+
+let render;
+
+export default async(ssrContext) => {
+  // Workaround for stub mode
+  // https://github.com/nuxt/framework/pull/3983
+  process.server = true;
+
+  // Invalidate cache for files changed since last rendering
+  const invalidates = await $fetch('/invalidates', {
+    baseURL: viteNodeOptions.baseURL,
+  });
+  const updates = runner.moduleCache.invalidateDepTree(invalidates);
+
+  // Execute SSR bundle on demand
+  const start = performance.now();
+  render = render || (await runner.executeFile(viteNodeOptions.entryPath)).default;
+  if (updates.size) {
+    const time = Math.round((performance.now() - start) * 1000) / 1000;
+    consola.success(`Vite server hmr ${updates.size} files`, time ? `in ${time}ms` : '');
+  }
+
+  const result = await render(ssrContext);
+  return result;
+};

package/dist/head/runtime/plugin.mjs

@@ -1,6 +1,5 @@
 import { defineFlowPlugin } from "#app";
 export default defineFlowPlugin((flow) => {
   flow._useHead = (_meta) => {
-    console.log(_meta);
   };
 });