@monkeyplus/flow 5.0.0-rc.86 → 5.0.0-rc.87

package/dist/chunks/vite-node.mjs

@@ -0,0 +1,149 @@
+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 'consola';
+import 'vite';
+import 'perfect-debounce';
+import 'node:fs';
+import 'nitropack';
+import 'defu';
+import 'node:module';
+import 'chokidar';
+import 'untyped';
+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/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);
   };
 });