@monkeyplus/flow 4.0.0-beta.8 → 5.0.0-beta.1

package/src/core/vite/builder/dev-bundler.ts

@@ -0,0 +1,247 @@
+import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { resolve } from 'pathe';
+import type * as vite from 'vite';
+import type { ExternalsOptions } from 'externality';
+import { ExternalsDefaults, isExternal as _isExternal } from 'externality';
+import { genDynamicImport, genObjectFromRawEntries } from 'knitwork';
+import { hashId, uniq } from './utils';
+
+export interface TransformChunk {
+  id: string
+  code: string
+  deps: string[]
+  parents: string[]
+}
+
+export interface SSRTransformResult {
+  code: string
+  map: object
+  deps: string[]
+  dynamicDeps: string[]
+}
+
+export interface TransformOptions {
+  viteServer: vite.ViteDevServer
+}
+
+function isExternal(opts: TransformOptions, id: string) {
+  // Externals
+  const ssrConfig = (opts.viteServer.config as any).ssr;
+
+  const externalOpts: ExternalsOptions = {
+    inline: [
+      /virtual:/,
+      /\.ts$/,
+      ...ExternalsDefaults.inline,
+      ...ssrConfig.noExternal,
+    ],
+    external: [
+      ...ssrConfig.external,
+      /node_modules/,
+    ],
+    resolve: {
+      type: 'module',
+      extensions: ['.ts', '.js', '.json', '.vue', '.mjs', '.jsx', '.tsx', '.wasm'],
+    },
+  };
+  return _isExternal(id, opts.viteServer.config.root, externalOpts);
+}
+
+async function transformRequest(opts: TransformOptions, id: string) {
+  // Virtual modules start with `\0`
+  if (id && id.startsWith('/@id/__x00__'))
+    id = `\0${id.slice('/@id/__x00__'.length)}`;
+
+  if (id && id.startsWith('/@id/'))
+    id = id.slice('/@id/'.length);
+
+  if (id && id.startsWith('/@fs/')) {
+    // Absolute path
+    id = id.slice('/@fs'.length);
+    // On Windows, this may be `/C:/my/path` at this point, in which case we want to remove the `/`
+    if (id.match(/^\/\w:/))
+      id = id.slice(1);
+  }
+  else if (!id.includes('entry') && id.startsWith('/')) {
+    // Relative to the root directory
+    const resolvedPath = resolve(opts.viteServer.config.root, `.${id}`);
+    if (existsSync(resolvedPath))
+      id = resolvedPath;
+  }
+
+  // Vite will add ?v=123 to bypass browser cache
+  // Remove for externals
+  const withoutVersionQuery = id.replace(/\?v=\w+$/, '');
+  if (await isExternal(opts, withoutVersionQuery)) {
+    const path = builtinModules.includes(withoutVersionQuery.split('node:').pop())
+      ? withoutVersionQuery
+      : pathToFileURL(withoutVersionQuery).href;
+    return {
+      code: `(global, module, _, exports, importMeta, ssrImport, ssrDynamicImport, ssrExportAll) =>
+${genDynamicImport(path, { wrapper: false })}
+  .then(r => {
+    if (r.default && r.default.__esModule)
+      r = r.default
+    exports.default = r.default
+    ssrExportAll(r)
+  })
+  .catch(e => {
+    console.error(e)
+    throw new Error(${JSON.stringify(`[vite dev] Error loading external "${id}".`)})
+  })`,
+      deps: [],
+      dynamicDeps: [],
+    };
+  }
+
+  // Transform
+  const res: SSRTransformResult = await opts.viteServer.transformRequest(id, { ssr: true }).catch((err) => {
+    // eslint-disable-next-line no-console
+    console.warn(`[SSR] Error transforming ${id}:`, err);
+    // console.error(err)
+  }) as SSRTransformResult || { code: '', map: {}, deps: [], dynamicDeps: [] };
+
+  // Wrap into a vite module
+  const code = `async function (global, module, exports, __vite_ssr_exports__, __vite_ssr_import_meta__, __vite_ssr_import__, __vite_ssr_dynamic_import__, __vite_ssr_exportAll__) {
+${res.code || '/* empty */'};
+}`;
+  return { code, deps: res.deps || [], dynamicDeps: res.dynamicDeps || [] };
+}
+
+async function transformRequestRecursive(opts: TransformOptions, id: any, parent = '<entry>', chunks: Record<string, TransformChunk> = {}) {
+  if (chunks[id]) {
+    chunks[id].parents.push(parent);
+    return;
+  }
+  const res = await transformRequest(opts, id);
+  const deps = uniq([...res.deps, ...res.dynamicDeps]);
+
+  chunks[id] = {
+    id,
+    code: res.code,
+    deps,
+    parents: [parent],
+  } as TransformChunk;
+  for (const dep of deps)
+    await transformRequestRecursive(opts, dep, id, chunks);
+
+  return Object.values(chunks);
+}
+
+export async function bundleRequest(opts: TransformOptions, entryURL: string) {
+  const chunks = await transformRequestRecursive(opts, entryURL);
+
+  const listIds = (ids: string[]) => ids.map((id) => `// - ${id} (${hashId(id)})`).join('\n');
+  const chunksCode = chunks!.map((chunk) => `
+// --------------------
+// Request: ${chunk.id}
+// Parents: \n${listIds(chunk.parents)}
+// Dependencies: \n${listIds(chunk.deps)}
+// --------------------
+const ${hashId(chunk.id)} = ${chunk.code}
+`).join('\n');
+
+  const manifestCode = `const __modules__ = ${
+    genObjectFromRawEntries(chunks!.map((chunk) => [chunk.id, hashId(chunk.id)]))
+  }`;
+
+  // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/ssr/ssrModuleLoader.ts
+  const ssrModuleLoader = `
+const __pendingModules__ = new Map()
+const __pendingImports__ = new Map()
+const __ssrContext__ = { global: globalThis }
+
+function __ssrLoadModule__(url, urlStack = []) {
+  const pendingModule = __pendingModules__.get(url)
+  if (pendingModule) { return pendingModule }
+  const modulePromise = __instantiateModule__(url, urlStack)
+  __pendingModules__.set(url, modulePromise)
+  modulePromise.catch(() => { __pendingModules__.delete(url) })
+         .finally(() => { __pendingModules__.delete(url) })
+  return modulePromise
+}
+
+async function __instantiateModule__(url, urlStack) {
+  const mod = __modules__[url]
+  if (mod.stubModule) { return mod.stubModule }
+  const stubModule = { [Symbol.toStringTag]: 'Module' }
+  Object.defineProperty(stubModule, '__esModule', { value: true })
+  mod.stubModule = stubModule
+  // https://vitejs.dev/guide/api-hmr.html
+  const importMeta = { url, hot: { accept() {}, prune() {}, dispose() {}, invalidate() {}, decline() {}, on() {} } }
+  urlStack = urlStack.concat(url)
+  const isCircular = url => urlStack.includes(url)
+  const pendingDeps = []
+  const ssrImport = async (dep) => {
+    // TODO: Handle externals if dep[0] !== '.' | '/'
+    if (!isCircular(dep) && !__pendingImports__.get(dep)?.some(isCircular)) {
+      pendingDeps.push(dep)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.set(url, pendingDeps)
+      }
+      await __ssrLoadModule__(dep, urlStack)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.delete(url)
+      } else {
+        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
+      }
+    }
+    return __modules__[dep].stubModule
+  }
+  function ssrDynamicImport (dep) {
+    // TODO: Handle dynamic import starting with . relative to url
+    return ssrImport(dep)
+  }
+
+  function ssrExportAll(sourceModule) {
+    for (const key in sourceModule) {
+      if (key !== 'default') {
+        try {
+          Object.defineProperty(stubModule, key, {
+            enumerable: true,
+            configurable: true,
+            get() { return sourceModule[key] }
+          })
+        } catch (_err) { }
+      }
+    }
+  }
+
+  const cjsModule = {
+    get exports () {
+      return stubModule.default
+    },
+    set exports (v) {
+      stubModule.default = v
+    },
+  }
+
+  await mod(
+    __ssrContext__.global,
+    cjsModule,
+    stubModule.default,
+    stubModule,
+    importMeta,
+    ssrImport,
+    ssrDynamicImport,
+    ssrExportAll
+  )
+
+  return stubModule
+}
+`;
+
+  const code = [
+    chunksCode,
+    manifestCode,
+    ssrModuleLoader,
+    `export default await __ssrLoadModule__(${JSON.stringify(entryURL)})`,
+  ].join('\n\n');
+
+  return {
+    code,
+    ids: chunks!.map((i) => i.id),
+  };
+}

package/src/core/vite/builder/index.ts

@@ -0,0 +1,92 @@
+import { isIgnoredFlow, logger } from '@monkeyplus/flow-kit';
+import type { Flow } from '@monkeyplus/flow-schema';
+import { getPort } from 'get-port-please';
+import * as vite from 'vite';
+import { resolve } from 'pathe';
+import { sanitizeFilePath } from 'mlly';
+import replace from '@rollup/plugin-replace';
+import { warmupViteServer } from './utils/warmup';
+import { buildServer } from './server';
+import type { ViteBuildContext } from './types';
+import virtual from './plugins/virtual';
+import { DynamicBasePlugin } from './plugins/dynamic-base';
+
+export async function bundleVite(flow: Flow) {
+  const hmrPortDefault = 24678; // Vite's default HMR port
+  const hmrPort = await getPort({
+    port: hmrPortDefault,
+    ports: Array.from({ length: 20 }, (_, i) => hmrPortDefault + 1 + i),
+  });
+
+  const ctx: ViteBuildContext = {
+    nuxt: flow,
+    flow,
+    config: vite.mergeConfig({
+      resolve: {
+        alias: {
+          ...flow.options.alias,
+          '#app': flow.options.appDir,
+          '#build/plugins': resolve(flow.options.buildDir, 'plugins/server'),
+          '#build': flow.options.buildDir,
+          '/entry.mjs': resolve(flow.options.appDir, 'entry'),
+
+        },
+      },
+      optimizeDeps: {
+        entries: [
+          resolve(flow.options.appDir, 'entry.ts'),
+        ],
+        include: [],
+      },
+      // css: resolveCSSOptions(nuxt),
+      build: {
+        rollupOptions: {
+          output: { sanitizeFileName: sanitizeFilePath },
+          input: resolve(flow.options.appDir, 'entry'),
+        },
+      },
+      plugins: [
+        replace({
+          ...Object.fromEntries([';', '(', '{', '}', ' ', '\t', '\n'].map((d) => [`${d}global.`, `${d}globalThis.`])),
+          preventAssignment: true,
+        }),
+        virtual(flow.vfs),
+        DynamicBasePlugin.vite({ sourcemap: flow.options.sourcemap }),
+      ],
+      server: {
+        watch: {
+          ignored: isIgnoredFlow,
+        },
+        hmr: {
+          // https://github.com/nuxt/framework/issues/4191
+          protocol: 'ws',
+          clientPort: hmrPort,
+          port: hmrPort,
+        },
+        fs: {
+          allow: [
+            flow.options.appDir,
+          ],
+        },
+      },
+    }, flow.options.vite),
+  };
+  await flow.callHook('vite:extend', ctx);
+
+  flow.hook('vite:serverCreated', (server: vite.ViteDevServer) => {
+    // Invalidate virtual modules when templates are re-generated
+    ctx.nuxt.hook('app:templatesGenerated', () => {
+      for (const [id, mod] of server.moduleGraph.idToModuleMap) {
+        if (id.startsWith('\x00virtual:'))
+          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);
+  });
+
+  await buildServer(ctx);
+}

package/src/core/vite/builder/manifest.ts

@@ -0,0 +1,33 @@
+import fse from 'fs-extra';
+import { resolve } from 'pathe';
+import { joinURL } from 'ufo';
+import type { ViteBuildContext } from './types';
+
+export async function writeManifest(ctx: ViteBuildContext, extraEntries: string[] = []) {
+  // Write client manifest for use in vue-bundle-renderer
+  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,
+  ];
+
+  // Legacy dev manifest
+  const devClientManifest = {
+    publicPath: joinURL(ctx.flow.options.app.baseURL, ctx.flow.options.app.buildAssetsDir),
+    all: entries,
+    initial: entries,
+    async: [],
+    modules: {},
+  };
+
+  const clientManifest = ctx.flow.options.dev
+    ? devClientManifest
+    : await fse.readJSON(resolve(clientDist, 'manifest.json'));
+
+  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');
+}

package/src/core/vite/builder/plugins/analyze.ts

@@ -0,0 +1,32 @@
+// import type { Plugin } from 'vite';
+// import { transform } from 'esbuild';
+// // import { visualizer } from 'rollup-plugin-visualizer';
+// import type { ViteBuildContext } from '../types';
+
+// export function analyzePlugin(ctx: ViteBuildContext): Plugin[] {
+//   return [
+//     {
+//       name: 'nuxt:analyze-minify',
+//       async generateBundle(_opts, outputBundle) {
+//         for (const [_bundleId, bundle] of Object.entries(outputBundle)) {
+//           if (bundle.type !== 'chunk') continue;
+//           const originalEntries = Object.entries(bundle.modules);
+//           const minifiedEntries = await Promise.all(originalEntries.map(async([moduleId, module]) => {
+//             const { code } = await transform(module.code || '', { minify: true });
+//             return [moduleId, { ...module, code }];
+//           }));
+//           bundle.modules = Object.fromEntries(minifiedEntries);
+//         }
+//         return null;
+//       },
+//     },
+//     // visualizer({
+//     //   // @ts-ignore
+//     //   ...ctx.flow.options?.build?.analyze as any,
+//     //   // @ts-ignore
+//     //   filename: ctx.flow.options.build.analyze.filename.replace('{name}', 'client'),
+//     //   title: 'Client bundle stats',
+//     //   gzipSize: true,
+//     // }),
+//   ];
+// }

package/src/core/vite/builder/plugins/cache-dir.ts

@@ -0,0 +1,13 @@
+import { resolve } from 'pathe';
+import type { Plugin } from 'vite';
+
+export function cacheDirPlugin(rootDir: string, name: string) {
+  const optimizeCacheDir = resolve(rootDir, 'node_modules/.cache/vite', name);
+  return <Plugin> {
+    name: 'flow:cache-dir',
+    configResolved(resolvedConfig) {
+      // @ts-ignore
+      resolvedConfig.optimizeCacheDir = optimizeCacheDir;
+    },
+  };
+}

package/src/core/vite/builder/plugins/dynamic-base.ts

@@ -0,0 +1,64 @@
+import { createUnplugin } from 'unplugin';
+
+import MagicString from 'magic-string';
+
+interface DynamicBasePluginOptions {
+  globalPublicPath?: string
+  sourcemap?: boolean
+}
+
+const VITE_ASSET_RE = /^export default ["'](__VITE_ASSET.*)["']$/;
+
+export const DynamicBasePlugin = createUnplugin((options: DynamicBasePluginOptions = {}) => {
+  return {
+    name: 'nuxt:dynamic-base-path',
+    resolveId(id) {
+      if (id.startsWith('/__NUXT_BASE__'))
+        return id.replace('/__NUXT_BASE__', '');
+
+      if (id === '#internal/nitro') return '#internal/nitro';
+      return null;
+    },
+    enforce: 'post',
+    transform(code, id) {
+      const s = new MagicString(code);
+
+      if (options.globalPublicPath && id.includes('paths.mjs') && code.includes('const appConfig = '))
+        s.append(`${options.globalPublicPath} = buildAssetsURL();\n`);
+
+      const assetId = code.match(VITE_ASSET_RE);
+      if (assetId) {
+        s.overwrite(0, code.length,
+          [
+            'import { buildAssetsURL } from \'#build/paths.mjs\';',
+            `export default buildAssetsURL("${assetId[1]}".replace("/__NUXT_BASE__", ""));`,
+          ].join('\n'),
+        );
+      }
+
+      if (!id.includes('paths.mjs') && code.includes('NUXT_BASE') && !code.includes('import { publicAssetsURL as __publicAssetsURL }'))
+        s.prepend('import { publicAssetsURL as __publicAssetsURL } from \'#build/paths.mjs\';\n');
+
+      if (id === 'vite/preload-helper') {
+        // Define vite base path as buildAssetsUrl (i.e. including _nuxt/)
+        s.prepend('import { buildAssetsDir } from \'#build/paths.mjs\';\n');
+        s.replace(/const base = ['"]\/__NUXT_BASE__\/['"]/, 'const base = buildAssetsDir()');
+      }
+
+      // Sanitize imports
+      s.replace(/from *['"]\/__NUXT_BASE__(\/[^'"]*)['"]/g, 'from "$1"');
+
+      // Dynamically compute string URLs featuring baseURL
+      const delimiterRE = /(?<!(const base = |from *))(`([^`]*)\/__NUXT_BASE__\/([^`]*)`|'([^']*)\/__NUXT_BASE__\/([^']*)'|"([^"]*)\/__NUXT_BASE__\/([^"]*)")/g;
+      /* eslint-disable-next-line no-template-curly-in-string */
+      s.replace(delimiterRE, (r) => `\`${r.replace(/\/__NUXT_BASE__\//g, '${__publicAssetsURL()}').slice(1, -1)}\``);
+
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: options.sourcemap && s.generateMap({ source: id, includeContent: true }),
+        };
+      }
+    },
+  };
+});

package/src/core/vite/builder/plugins/virtual.ts

@@ -0,0 +1,45 @@
+import { dirname, isAbsolute, join, resolve } from 'pathe';
+import type { Plugin } from 'rollup';
+
+const PREFIX = 'virtual:';
+
+export default function virtual(vfs: Record<string, string>): Plugin {
+  const extensions = ['', '.ts', '.vue', '.mjs', '.cjs', '.js', '.json'];
+  const resolveWithExt = (id: any) => {
+    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)) {
+        // Add back C: prefix on Windows
+        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,
+      };
+    },
+  };
+}

package/src/core/vite/builder/server.ts

@@ -0,0 +1,163 @@
+import { join, normalize, resolve } from 'pathe';
+import * as vite from 'vite';
+import fse from 'fs-extra';
+import { withoutTrailingSlash } from 'ufo';
+import { logger } from '@monkeyplus/flow-kit';
+import { debounce } from 'perfect-debounce';
+import { cacheDirPlugin } from './plugins/cache-dir';
+import type { ViteBuildContext, ViteOptions } from './types';
+import { wpfs } from './utils/wpfs';
+import { bundleRequest } from './dev-bundler';
+import { writeManifest } from './manifest';
+import { isCSS, isDirectory, readDirRecursively } from './utils';
+
+export const buildServer = async(ctx: ViteBuildContext) => {
+  // const _resolve = (id: string) => resolveModule(id, { paths: ctx.flow.options.modulesDir });
+
+  const serverConfig: vite.InlineConfig = vite.mergeConfig(ctx.config, {
+    configFile: false,
+    define: {
+      'process.server': true,
+      'typeof window': '"undefined"',
+      'typeof document': '"undefined"',
+      'typeof navigator': '"undefined"',
+      'typeof location': '"undefined"',
+      'typeof XMLHttpRequest': '"undefined"',
+    },
+    ssr: {
+      noExternal: [
+        ...ctx.flow.options.build.transpile,
+        // TODO: Use externality for production (rollup) build
+        /\/esm\/.*\.js$/,
+        /\.(es|esm|esm-browser|esm-bundler).js$/,
+        '/__vue-jsx',
+        '#app',
+        /(nuxt|nuxt3)\/(dist|src|app)/,
+        /@nuxt\/nitro\/(dist|src)/,
+      ],
+    },
+    build: {
+      outDir: resolve(ctx.flow.options.buildDir, 'dist/server'),
+      manifest: true,
+      rollupOptions: {
+        external: ['#internal/nitro'],
+        output: {
+          entryFileNames: 'server.mjs',
+          preferConst: true,
+          format: 'module',
+        },
+        onwarn(warning, rollupWarn) {
+          if (!['UNUSED_EXTERNAL_IMPORT'].includes(warning.code))
+            rollupWarn(warning);
+        },
+      },
+    },
+    server: {
+      // https://github.com/vitest-dev/vitest/issues/229#issuecomment-1002685027
+      preTransformRequests: false,
+      cors: true,
+    },
+    plugins: [
+      cacheDirPlugin(ctx.flow.options.rootDir, 'server'),
+    ],
+  } as ViteOptions);
+
+  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');
+
+    // Remove public files that have been duplicated into buildAssetsDir
+    // TODO: Add option to configure this behavior in vite
+    const publicDir = join(ctx.flow.options.srcDir, ctx.flow.options.dir.public);
+    let publicFiles: string[] = [];
+    if (await isDirectory(publicDir)) {
+      publicFiles = readDirRecursively(publicDir).map((r) => r.replace(publicDir, ''));
+      for (const file of publicFiles) {
+        try {
+          fse.rmSync(join(clientDist, file));
+        }
+        catch {}
+      }
+    }
+
+    // Copy doubly-nested /_nuxt/_nuxt files into buildAssetsDir
+    // TODO: Workaround vite issue
+    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);
+      }
+    }
+  });
+
+  const onBuild = () => ctx.flow.callHook('build:resources', wpfs);
+
+  // Production build
+  if (!ctx.flow.options.dev) {
+    const start = Date.now();
+    logger.info('Building server...');
+    await vite.build(serverConfig);
+    await onBuild();
+    logger.success(`Server built in ${Date.now() - start}ms`);
+    return;
+  }
+
+  // if (!ctx.flow.options.ssr) {
+  //   await onBuild();
+  //   return;
+  // }
+  // console.log(serverConfig.plugins);
+
+  // Start development server
+  const viteServer = await vite.createServer(serverConfig);
+  ctx.ssrServer = viteServer;
+
+  await ctx.flow.callHook('vite:serverCreated', viteServer, { isClient: false, isServer: true });
+
+  // Close server on exit
+  ctx.flow.hook('close', () => viteServer.close());
+
+  // Initialize plugins
+  await viteServer.pluginContainer.buildStart({});
+  // console.log(viteServer.1);
+
+  // if (ctx.flow.options.experimental.viteNode) {
+  //   logger.info('Vite server using experimental `vite-node`...');
+  //   await prepareDevServerEntry(ctx);
+  // }
+  // else {
+  // Build and watch
+  const _doBuild = async() => {
+    const start = Date.now();
+    const { code, ids } = await bundleRequest({ viteServer }, resolve(ctx.flow.options.appDir, 'entry'));
+    await fse.ensureFile(resolve(ctx.flow.options.buildDir, 'dist/server/server.mjs'));
+    await fse.writeFile(resolve(ctx.flow.options.buildDir, 'dist/server/server.mjs'), code, 'utf-8');
+    // Have CSS in the manifest to prevent FOUC on dev SSR
+    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', {} as any);
+  };
+  const doBuild = debounce(_doBuild);
+
+  // Initial build
+  await _doBuild();
+
+  // Watch
+  viteServer.watcher.on('all', (_event, file) => {
+    file = normalize(file); // Fix windows paths
+    if (file.indexOf(ctx.flow.options.buildDir) === 0) return;
+    doBuild();
+  });
+  ctx.flow.hook('app:templatesGenerated', () => doBuild());
+
+  // ctx.nuxt.hook('builder:watch', () => doBuild())
+  // }
+};