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

package/dist/chunks/vite-node.mjs

@@ -1,149 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

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

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

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

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

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

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

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

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

@@ -1,42 +0,0 @@
-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/pages/runtime/pages.mjs

@@ -1,96 +0,0 @@
-import { joinURL } from "ufo";
-import consola from "consola";
-import { definePage } from "./helpers/index.mjs";
-import { defineFlowPlugin, useRuntimeConfig } from "#app";
-import pages from "#build/pages";
-import contexts from "#build/pages.contexts";
-export default defineFlowPlugin(async (flow) => {
-  const { app } = useRuntimeConfig();
-  const allPages = [];
-  const basePages = Object.entries(pages);
-  consola.success("Parsed %i pages files", basePages.length);
-  basePages.forEach(([name, _pages]) => {
-    const __pages = Array.isArray(_pages) ? _pages : [_pages];
-    __pages.forEach((page) => {
-      const { getPages } = definePage({
-        name,
-        ...page
-      });
-      const _pages2 = getPages(app.locale.location, app.locale.language, app.locale.locales);
-      _pages2.forEach((page2) => {
-        flow.router.byUrl.insert(page2.url, page2.context);
-        flow.router.byName.insert(page2.name, page2.context);
-        allPages.push(page2.context);
-      });
-    });
-  });
-  const cache = {};
-  async function getUrl(namePage, localeCode) {
-    const code = localeCode || this?.getLocale()?.code;
-    const [lang, loc] = code.split("-");
-    const name = joinURL("/", loc, lang, namePage);
-    const { path, params, page } = flow.router.byName.lookup(name) || {};
-    if (params?._ && page.dynamic) {
-      if (!cache[path]) {
-        cache[path] = this.defineCachedFunction(async (_ctx) => {
-          return await page.dynamic.method(_ctx);
-        }, { maxAge: 8, getKey: () => path, swr: false });
-      }
-      const fn = cache[path];
-      const list = await fn({ utils: this, locale: this.getLocale() });
-      const dPage = list.find((el) => el.name === params._);
-      return dPage ? path.replace("**", dPage.url) : "/404";
-    }
-    return path || "/404";
-  }
-  async function getUrls(withLocale = false) {
-    const urls = [];
-    for (const page of allPages) {
-      if (page.path.includes("/**") && page.page.dynamic) {
-        const dPages = await page.page.dynamic.method({
-          locale: page.locale,
-          utils: Object.assign({ getLocale: () => page.locale }, flow.app.utils),
-          chunks: {},
-          page: {}
-        });
-        dPages.forEach((dPage) => {
-          const _path = joinURL(page.path.replace("/**", ""), dPage.url);
-          urls.push(withLocale ? { url: _path, locale: page.locale.code, name: joinURL(page.name, dPage.name) } : _path);
-        });
-      } else {
-        const url = page.path.replaceAll("*", "");
-        urls.push(withLocale ? { url, locale: page.locale.code, name: page.name } : url);
-      }
-    }
-    return urls.sort();
-  }
-  async function getSharedContext(ctx) {
-    const entries = Object.entries(contexts);
-    if (!entries.length)
-      return {};
-    const _contexts = await Promise.all(entries.map(async ([key, method]) => {
-      const data = await method.setup(ctx);
-      const setupLocal = method?.locales?.[ctx.locale.code];
-      let dataLocal = {};
-      if (setupLocal)
-        dataLocal = await setupLocal(ctx);
-      const obj = method.merge ? { ...data, ...dataLocal } : { [key]: { ...data, ...dataLocal } };
-      return obj;
-    }));
-    return _contexts.reduce((acc, curr) => {
-      return {
-        ...acc,
-        ...curr
-      };
-    }, {});
-  }
-  flow.setUtil("getUrl", getUrl);
-  flow.setUtil("getUrls", getUrls);
-  flow.setUtil("getPages", () => allPages);
-  flow.setUtil("getSharedContext", getSharedContext);
-  return {
-    provide: {
-      pages: { allPages }
-    }
-  };
-});