@monkeyplus/flow 5.0.0-rc.91 → 5.0.0-rc.92

package/dist/app/entry.async.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeConfig } from '@monkeyplus/flow-schema';
+declare const _default: (ctx?: RuntimeConfig) => Promise<any>;
+export default _default;

package/dist/app/entry.async.mjs

@@ -0,0 +1 @@
+export default (ctx) => import("#app/entry").then((m) => m.default(ctx));

package/dist/chunks/dev-bundler.mjs

@@ -6,66 +6,47 @@ import { genObjectFromRawEntries, genDynamicImport } from 'knitwork';
 import fse from 'fs-extra';
 import { debounce } from 'perfect-debounce';
 import { isIgnoredFlow, logger } from '@monkeyplus/flow-kit';
-import { h as hashId, u as uniq, i as isCSS } from './index.mjs';
-import { ExternalsDefaults, isExternal } from 'externality';
-import { joinURL } from 'ufo';
-import 'hookable';
-import 'url';
-import 'unimport';
-import 'unplugin';
-import 'fs';
-import 'escape-string-regexp';
-import 'scule';
-import 'consola';
-import 'vite';
-import 'nitropack';
-import 'defu';
-import 'h3';
-import 'chokidar';
-import 'untyped';
-import 'mlly';
-import '@rollup/plugin-replace';
-import 'node:crypto';
+import { h as hashId, c as createIsExternal, u as uniq, i as isCSS } from './external.mjs';
+import { withTrailingSlash, withoutLeadingSlash } from 'ufo';
+import escapeRE from 'escape-string-regexp';
+import { normalizeViteManifest } from 'vue-bundle-renderer';
+import 'ohash';
+import 'externality';
 
-function createIsExternal(viteServer, rootDir) {
-  const externalOpts = {
-    inline: [
-      /virtual:/,
-      /\.ts$/,
-      ...ExternalsDefaults.inline,
-      ...viteServer.config.ssr.noExternal
-    ],
-    external: [
-      ...viteServer.config.ssr.external,
-      /node_modules/
-    ],
-    resolve: {
-      type: "module",
-      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
-    }
-  };
-  return (id) => isExternal(id, rootDir, externalOpts);
-}
-
-async function writeManifest(ctx, extraEntries = []) {
-  const clientDist = resolve(ctx.flow.options.buildDir, "dist/client");
-  const serverDist = resolve(ctx.flow.options.buildDir, "dist/server");
-  const entries = [
-    "@vite/client",
-    "entry.mjs",
-    ...extraEntries
-  ];
+async function writeManifest(ctx, css = []) {
+  const clientDist = resolve(ctx.nuxt.options.buildDir, "dist/client");
+  const serverDist = resolve(ctx.nuxt.options.buildDir, "dist/server");
   const devClientManifest = {
-    publicPath: joinURL(ctx.flow.options.app.baseURL, ctx.flow.options.app.buildAssetsDir),
-    all: entries,
-    initial: entries,
-    async: [],
-    modules: {}
+    "@vite/client": {
+      isEntry: true,
+      file: "@vite/client",
+      css,
+      module: true,
+      resourceType: "script"
+    },
+    [ctx.entry]: {
+      isEntry: true,
+      file: ctx.entry,
+      module: true,
+      resourceType: "script"
+    }
   };
-  const clientManifest = ctx.flow.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
+  const clientManifest = ctx.nuxt.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
+  const buildAssetsDir = withTrailingSlash(withoutLeadingSlash(ctx.nuxt.options.app.buildAssetsDir));
+  const BASE_RE = new RegExp(`^${escapeRE(buildAssetsDir)}`);
+  for (const key in clientManifest) {
+    if (clientManifest[key].file)
+      clientManifest[key].file = clientManifest[key].file.replace(BASE_RE, "");
+    for (const item of ["css", "assets"]) {
+      if (clientManifest[key][item])
+        clientManifest[key][item] = clientManifest[key][item].map((i) => i.replace(BASE_RE, ""));
+    }
+  }
   await fse.mkdirp(serverDist);
-  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(clientManifest, null, 2), "utf8");
-  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(clientManifest, null, 2)}`, "utf8");
+  const manifest = normalizeViteManifest(clientManifest);
+  await ctx.nuxt.callHook("build:manifest", manifest);
+  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(manifest, null, 2)}`, "utf8");
 }
 
 async function transformRequest(opts, id) {
@@ -242,19 +223,17 @@ async function initViteDevBundler(ctx, onBuild) {
   const _doBuild = async () => {
     const start = Date.now();
     const { code, ids } = await bundleRequest(options, ctx.entry);
-    await fse.ensureFile(resolve(ctx.flow.options.buildDir, "dist/server/server.mjs"));
+    await fse.ensureFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"));
     await fse.writeFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"), code, "utf-8");
     await writeManifest(ctx, ids.filter(isCSS).map((i) => i.slice(1)));
     const time = Date.now() - start;
     logger.success(`Vite server built in ${time}ms`);
     await onBuild();
-    ctx.flow.callHook("bundler:change", {});
+    ctx.nuxt.callHook("bundler:change", {});
   };
   const doBuild = debounce(_doBuild);
   await _doBuild();
   viteServer.watcher.on("all", (_event, file) => {
-    if (file.includes("/pages/"))
-      return;
     file = normalize(file);
     if (file.indexOf(ctx.nuxt.options.buildDir) === 0 || isIgnoredFlow(file))
       return;

package/dist/chunks/external.mjs

@@ -0,0 +1,37 @@
+import 'node:fs';
+import { hash } from 'ohash';
+import 'pathe';
+import { ExternalsDefaults, isExternal } from 'externality';
+
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+const IS_CSS_RE = /\.(?:css|scss|sass|postcss|less|stylus|styl)(\?[^.]+)?$/;
+function isCSS(file) {
+  return IS_CSS_RE.test(file);
+}
+function hashId(id) {
+  return `$id_${hash(id)}`;
+}
+
+function createIsExternal(viteServer, rootDir) {
+  const externalOpts = {
+    inline: [
+      /virtual:/,
+      /\.ts$/,
+      ...ExternalsDefaults.inline || [],
+      ...viteServer.config.ssr.noExternal
+    ],
+    external: [
+      ...viteServer.config.ssr.external || [],
+      /node_modules/
+    ],
+    resolve: {
+      type: "module",
+      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
+    }
+  };
+  return (id) => isExternal(id, rootDir, externalOpts);
+}
+
+export { createIsExternal as c, hashId as h, isCSS as i, uniq as u };

package/dist/chunks/index.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
 import { pathToFileURL } from 'node:url';
 import { createUnplugin } from 'unplugin';
-import { parseURL, parseQuery, joinURL, withoutTrailingSlash } from 'ufo';
+import { parseURL, parseQuery, joinURL } from 'ufo';
 import fs from 'fs';
 import escapeRE from 'escape-string-regexp';
 import { camelCase, pascalCase } from 'scule';
@@ -15,18 +15,18 @@ import logger$1 from 'consola';
 import * as vite from 'vite';
 import { createServer, build as build$1 } from 'vite';
 import { debounce } from 'perfect-debounce';
-import { existsSync, promises, readdirSync, statSync } from 'node:fs';
+import { existsSync, promises } from 'node:fs';
 import { createNitro, scanHandlers, writeTypes, build as build$2, prepare, copyPublicAssets, prerender, createDevServer } from 'nitropack';
 import defu from 'defu';
 import { dynamicEventHandler, toEventHandler } from 'h3';
 import { createRequire } from 'node:module';
 import chokidar from 'chokidar';
 import { generateTypes, resolveSchema } from 'untyped';
-import { sanitizeFilePath } from 'mlly';
 import replace from '@rollup/plugin-replace';
-import { createHash } from 'node:crypto';
+import { sanitizeFilePath } from 'mlly';
+import { resolveTSConfig } from 'pkg-types';
 
-const version = "5.0.0-rc.91";
+const version = "5.0.0-rc.92";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -379,7 +379,7 @@ const builClient = async (flow) => {
     root: flow.options.rootDir,
     mode: "production",
     build: {
-      outDir: ".vite",
+      outDir: "node_modules/.vite_flow",
       manifest: true
     }
   });
@@ -418,7 +418,7 @@ const viteModule = defineFlowModule({
         }
       });
     } else {
-      const file = resolve(flow.options.rootDir, ".vite/manifest.json");
+      const file = resolve(flow.options.rootDir, "node_modules/.vite_flow/manifest.json");
       addTemplate({
         filename: "viteManifest.mjs",
         async getContents() {
@@ -438,7 +438,7 @@ const viteModule = defineFlowModule({
         logger$1.success(`Client build in ${Date.now() - start}ms`);
       });
       flow.hook("generate:before", async () => {
-        const files = resolve(flow.options.rootDir, ".vite/assets");
+        const files = resolve(flow.options.rootDir, "node_modules/.vite_flow/assets");
         await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
       });
     }
@@ -487,6 +487,9 @@ async function initNitro(flow) {
     nodeModulesDirs: flow.options.modulesDir,
     handlers,
     devHandlers: [],
+    output: {
+      dir: resolve(flow.options.buildDir, "output")
+    },
     baseURL: flow.options.app.baseURL,
     runtimeConfig: {
       ...flow.options.runtimeConfig,
@@ -850,6 +853,49 @@ function uniqueBy(arr, key) {
   return res;
 }
 
+const PREFIX = "virtual:nuxt:";
+function virtual(vfs) {
+  const extensions = ["", ".ts", ".vue", ".mjs", ".cjs", ".js", ".json"];
+  const resolveWithExt = (id) => {
+    for (const ext of extensions) {
+      const rId = id + ext;
+      if (rId in vfs)
+        return rId;
+    }
+    return null;
+  };
+  return {
+    name: "virtual",
+    resolveId(id, importer) {
+      if (process.platform === "win32" && isAbsolute(id)) {
+        id = resolve(id);
+      }
+      const resolvedId = resolveWithExt(id);
+      if (resolvedId)
+        return PREFIX + resolvedId;
+      if (importer && !isAbsolute(id)) {
+        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
+        const importedDir = dirname(importerNoPrefix);
+        const resolved = resolveWithExt(join(importedDir, id));
+        if (resolved)
+          return PREFIX + resolved;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(PREFIX))
+        return null;
+      const idNoPrefix = id.slice(PREFIX.length);
+      if (idNoPrefix in vfs) {
+        return {
+          code: vfs[idNoPrefix],
+          map: null
+        };
+      }
+    }
+  };
+}
+
 async function warmupViteServer(server, entries) {
   const warmedUrls = /* @__PURE__ */ new Set();
   const warmup = async (url) => {
@@ -868,6 +914,11 @@ async function warmupViteServer(server, entries) {
   await Promise.all(entries.map((entry) => warmup(entry)));
 }
 
+const wpfs = {
+  ...fse,
+  join
+};
+
 function cacheDirPlugin(rootDir, name) {
   const optimizeCacheDir = resolve(rootDir, "node_modules/.cache/vite", name);
   return {
@@ -878,54 +929,27 @@ function cacheDirPlugin(rootDir, name) {
   };
 }
 
-const wpfs = {
-  ...fse,
-  join
-};
-
-function uniq(arr) {
-  return Array.from(new Set(arr));
-}
-const IS_CSS_RE = /\.(?:css|scss|sass|postcss|less|stylus|styl)(\?[^.]+)?$/;
-function isCSS(file) {
-  return IS_CSS_RE.test(file);
-}
-function hashId(id) {
-  return `$id_${hash(id)}`;
-}
-function hash(input, length = 8) {
-  return createHash("sha256").update(input).digest("hex").slice(0, length);
-}
-function readDirRecursively(dir) {
-  return readdirSync(dir).reduce((files, file) => {
-    const name = join(dir, file);
-    const isDirectory2 = statSync(name).isDirectory();
-    return isDirectory2 ? [...files, ...readDirRecursively(name)] : [...files, name];
-  }, []);
-}
-async function isDirectory(path) {
-  try {
-    return (await promises.stat(path)).isDirectory();
-  } catch (_err) {
-    return false;
-  }
-}
-
-const buildServer = async (ctx) => {
+async function buildServer(ctx) {
   const serverConfig = vite.mergeConfig(ctx.config, {
-    configFile: false,
+    base: ctx.nuxt.options.dev ? joinURL(ctx.nuxt.options.app.baseURL.replace(/^\.\//, "/") || "/", ctx.nuxt.options.app.buildAssetsDir) : void 0,
     define: {
       "process.server": true,
+      "process.client": false,
       "typeof window": '"undefined"',
       "typeof document": '"undefined"',
       "typeof navigator": '"undefined"',
       "typeof location": '"undefined"',
       "typeof XMLHttpRequest": '"undefined"'
     },
+    resolve: {
+      alias: {
+        "#build/plugins": resolve(ctx.nuxt.options.buildDir, "plugins/server")
+      }
+    },
     ssr: {
-      external: ctx.nuxt.options.experimental.externalVue ? ["#internal/nitro", "#internal/nitro/utils", "vue", "vue-router"] : ["#internal/nitro", "#internal/nitro/utils"],
+      external: ["#internal/nitro", "#internal/nitro/utils"],
       noExternal: [
-        ...ctx.flow.options.build.transpile,
+        ...ctx.nuxt.options.build.transpile,
         /\/esm\/.*\.js$/,
         /\.(es|esm|esm-browser|esm-bundler).js$/,
         "/__vue-jsx",
@@ -938,13 +962,14 @@ const buildServer = async (ctx) => {
       ]
     },
     build: {
-      outDir: resolve(ctx.flow.options.buildDir, "dist/server"),
+      outDir: resolve(ctx.nuxt.options.buildDir, "dist/server"),
       ssr: true,
       rollupOptions: {
         external: ["#internal/nitro"],
         output: {
           entryFileNames: "server.mjs",
           preferConst: true,
+          inlineDynamicImports: !ctx.nuxt.options.experimental.viteServerDynamicImports,
           format: "module"
         },
         onwarn(warning, rollupWarn) {
@@ -955,38 +980,23 @@ const buildServer = async (ctx) => {
     },
     server: {
       preTransformRequests: false,
-      cors: true
+      hmr: false
     },
     plugins: [
-      cacheDirPlugin(ctx.flow.options.rootDir, "server")
+      cacheDirPlugin(ctx.nuxt.options.rootDir, "server")
     ]
   });
-  await ctx.flow.callHook("vite:extendConfig", serverConfig, { isClient: false, isServer: true });
-  ctx.flow.hook("nitro:build:before", async () => {
-    if (ctx.flow.options.dev)
-      return;
-    const clientDist = resolve(ctx.flow.options.buildDir, "dist/client");
-    const publicDir = join(ctx.flow.options.srcDir, ctx.flow.options.dir.public);
-    let publicFiles = [];
-    if (await isDirectory(publicDir)) {
-      publicFiles = readDirRecursively(publicDir).map((r) => r.replace(publicDir, ""));
-      for (const file of publicFiles) {
-        try {
-          fse.rmSync(join(clientDist, file));
-        } catch {
-        }
-      }
-    }
-    if (await isDirectory(clientDist)) {
-      const nestedAssetsPath = withoutTrailingSlash(join(clientDist, ctx.flow.options.app.buildAssetsDir));
-      if (await isDirectory(nestedAssetsPath)) {
-        await fse.copy(nestedAssetsPath, clientDist, { recursive: true });
-        await fse.remove(nestedAssetsPath);
+  if (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev) {
+    const checker = await import('vite-plugin-checker').then((r) => r.default);
+    serverConfig.plugins.push(checker({
+      vueTsc: {
+        tsconfigPath: await resolveTSConfig(ctx.nuxt.options.rootDir)
       }
-    }
-  });
-  const onBuild = () => ctx.flow.callHook("build:resources", wpfs);
-  if (!ctx.flow.options.dev) {
+    }));
+  }
+  await ctx.nuxt.callHook("vite:extendConfig", serverConfig, { isClient: false, isServer: true });
+  const onBuild = () => ctx.nuxt.callHook("build:resources", wpfs);
+  if (!ctx.nuxt.options.dev) {
     const start = Date.now();
     logger.info("Building server...");
     await vite.build(serverConfig);
@@ -994,125 +1004,93 @@ const buildServer = async (ctx) => {
     logger.success(`Server built in ${Date.now() - start}ms`);
     return;
   }
+  if (!ctx.nuxt.options.ssr) {
+    await onBuild();
+    return;
+  }
   const viteServer = await vite.createServer(serverConfig);
   ctx.ssrServer = viteServer;
-  await ctx.flow.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
-  ctx.flow.hook("close", () => viteServer.close());
+  await ctx.nuxt.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
+  ctx.nuxt.hook("close", () => viteServer.close());
   await viteServer.pluginContainer.buildStart({});
-  if (ctx.nuxt.options.experimental.viteNode)
+  if (ctx.nuxt.options.experimental.viteNode) {
     logger.info("Vite server using experimental `vite-node`...");
-  else
+    await import('./vite-node.mjs').then((r) => r.initViteNodeServer(ctx));
+  } else {
     await import('./dev-bundler.mjs').then((r) => r.initViteDevBundler(ctx, onBuild));
-};
-
-const PREFIX = "virtual:";
-function virtual(vfs) {
-  const extensions = ["", ".ts", ".vue", ".mjs", ".cjs", ".js", ".json"];
-  const resolveWithExt = (id) => {
-    for (const ext of extensions) {
-      const rId = id + ext;
-      if (rId in vfs)
-        return rId;
-    }
-    return null;
-  };
-  return {
-    name: "virtual",
-    resolveId(id, importer) {
-      if (process.platform === "win32" && isAbsolute(id)) {
-        id = resolve(id);
-      }
-      const resolvedId = resolveWithExt(id);
-      if (resolvedId)
-        return PREFIX + resolvedId;
-      if (importer && !isAbsolute(id)) {
-        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
-        const importedDir = dirname(importerNoPrefix);
-        const resolved = resolveWithExt(join(importedDir, id));
-        if (resolved)
-          return PREFIX + resolved;
-      }
-      return null;
-    },
-    load(id) {
-      if (!id.startsWith(PREFIX))
-        return null;
-      const idNoPrefix = id.slice(PREFIX.length);
-      return {
-        code: vfs[idNoPrefix],
-        map: null
-      };
-    }
-  };
+  }
 }
 
-async function bundleVite(flow) {
-  const entry = resolve(flow.options.appDir, flow.options.experimental.asyncEntry ? "entry.async" : "entry");
+async function bundle$1(nuxt) {
+  const entry = resolve(nuxt.options.appDir, nuxt.options.experimental.asyncEntry ? "entry.async" : "entry");
   const ctx = {
-    nuxt: flow,
-    flow,
+    nuxt,
     entry,
-    config: vite.mergeConfig({
-      configFile: false,
-      resolve: {
-        alias: {
-          ...flow.options.alias,
-          "#app": flow.options.appDir,
-          "#build/plugins": resolve(flow.options.buildDir, "plugins/server"),
-          "#build": flow.options.buildDir
-        }
-      },
-      optimizeDeps: {
-        entries: [
-          entry
+    config: vite.mergeConfig(
+      {
+        configFile: false,
+        resolve: {
+          alias: {
+            ...nuxt.options.alias,
+            "#app": nuxt.options.appDir,
+            "#build/plugins": "",
+            "#build": nuxt.options.buildDir,
+            "web-streams-polyfill/ponyfill/es2018": "unenv/runtime/mock/empty",
+            "abort-controller": "unenv/runtime/mock/empty"
+          }
+        },
+        optimizeDeps: {
+          entries: [entry],
+          include: []
+        },
+        build: {
+          rollupOptions: {
+            output: { sanitizeFileName: sanitizeFilePath },
+            input: resolve(nuxt.options.appDir, "entry")
+          },
+          watch: {
+            exclude: nuxt.options.ignore
+          }
+        },
+        plugins: [
+          replace({
+            ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
+            preventAssignment: true
+          }),
+          virtual(nuxt.vfs)
         ],
-        include: ["vue"]
-      },
-      build: {
-        rollupOptions: {
-          output: { sanitizeFileName: sanitizeFilePath },
-          input: resolve(flow.options.appDir, "entry")
+        vue: {
+          reactivityTransform: nuxt.options.experimental.reactivityTransform
         },
-        watch: {
-          exclude: flow.options.ignore
+        server: {
+          watch: { ignored: isIgnoredFlow },
+          fs: {
+            allow: [
+              nuxt.options.appDir
+            ]
+          },
+          hmr: false
         }
       },
-      plugins: [
-        replace({
-          ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
-          preventAssignment: true
-        }),
-        virtual(flow.vfs)
-      ],
-      server: {
-        watch: {
-          ignored: isIgnoredFlow
-        },
-        hmr: false,
-        fs: {
-          allow: [
-            flow.options.appDir
-          ]
-        }
-      }
-    }, flow.options.vite)
+      nuxt.options.vite
+    )
   };
-  if (!flow.options.dev) {
+  if (!nuxt.options.dev) {
     ctx.config.server.watch = void 0;
     ctx.config.build.watch = void 0;
   }
-  await flow.callHook("vite:extend", ctx);
-  flow.hook("vite:serverCreated", (server) => {
+  await nuxt.callHook("vite:extend", ctx);
+  nuxt.hook("vite:serverCreated", (server, env) => {
     ctx.nuxt.hook("app:templatesGenerated", () => {
       for (const [id, mod] of server.moduleGraph.idToModuleMap) {
         if (id.includes("pages."))
           server.moduleGraph.invalidateModule(mod);
-        if (id.startsWith("\0virtual:"))
+        if (id.startsWith("\virtual:"))
           server.moduleGraph.invalidateModule(mod);
       }
     });
     const start = Date.now();
-    warmupViteServer(server, ["/entry.mjs"]).then(() => logger.info(`Vite server warmed up in ${Date.now() - start}ms`)).catch(logger.error);
+    warmupViteServer(server, [join("/@fs/", ctx.entry)]).then(() => logger.info(`Vite ${env.isClient ? "client" : "server"} warmed up in ${Date.now() - start}ms`)).catch(logger.error);
   });
   await buildServer(ctx);
 }
@@ -1154,11 +1132,11 @@ function watch(flow) {
 }
 async function bundle(nuxt) {
   try {
-    return bundleVite(nuxt);
+    return bundle$1(nuxt);
   } catch (error) {
     await nuxt.callHook("build:error", error);
     throw error;
   }
 }
 
-export { build as b, createFlow as c, defineFlowConfig as d, hashId as h, isCSS as i, loadFlow as l, uniq as u };
+export { defineFlowConfig as a, build as b, createFlow as c, distDir as d, loadFlow as l };

package/dist/chunks/vite-node.mjs

@@ -0,0 +1,155 @@
+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);
   };
 });

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { b as build, c as createFlow, d as defineFlowConfig, l as loadFlow } from './chunks/index.mjs';
+export { b as build, c as createFlow, a as defineFlowConfig, l as loadFlow } from './chunks/index.mjs';
 import 'hookable';
 import 'pathe';
 import '@monkeyplus/flow-kit';
@@ -22,6 +22,6 @@ import 'h3';
 import 'node:module';
 import 'chokidar';
 import 'untyped';
-import 'mlly';
 import '@rollup/plugin-replace';
-import 'node:crypto';
+import 'mlly';
+import 'pkg-types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.91",
+  "version": "5.0.0-rc.92",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -25,12 +25,11 @@
     "dist"
   ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.91",
-    "@monkeyplus/flow-kit": "5.0.0-rc.91",
-    "@monkeyplus/flow-schema": "5.0.0-rc.91",
+    "@monkeyplus/flow-cli": "5.0.0-rc.92",
+    "@monkeyplus/flow-kit": "5.0.0-rc.92",
+    "@monkeyplus/flow-schema": "5.0.0-rc.92",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
-    "pkg-types": "^0.3.4",
     "c12": "^0.2.8",
     "chokidar": "^3.5.3",
     "consola": "^2.15.3",
@@ -46,6 +45,7 @@
     "h3": "^0.7.16",
     "hookable": "^5.1.1",
     "jiti": "^1.14.0",
+    "ohash": "^0.1.5",
     "knitwork": "^0.1.2",
     "listhen": "^0.2.13",
     "magic-string": "^0.26.2",
@@ -65,9 +65,12 @@
     "unctx": "^2.0.1",
     "unimport": "^0.4.5",
     "unplugin": "^0.9.4",
-    "std-env": "^3.1.1",
-    "untyped": "^0.4.4",
-    "vite": "^3.0.9",
+    "untyped": "^0.4.5",
+    "pkg-types": "^0.3.3",
+    "vite": "2.9.15",
+    "vite-node": "^0.22.1",
+    "vite-plugin-checker": "^0.4.9",
+    "vue-bundle-renderer": "^0.4.2",
     "vue": "^3.2.37"
   },
   "devDependencies": {