@monkeyplus/flow 5.0.0-rc.79 → 5.0.0-rc.8

package/dist/app/flow.d.ts

@@ -1,6 +1,6 @@
 import type { RadixRouter } from 'radix3';
 import type { Hookable } from 'hookable';
-import type { FlowAppUtils, FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
+import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
 declare type HookResult = Promise<void> | void;
 export interface FlowAppHooks {
     'flow:pages': (page: FlowPage[]) => HookResult;
@@ -11,10 +11,6 @@ export interface FlowAppHooks {
         bodyStart: string[];
     }) => HookResult;
     'page:links': (links: string[]) => HookResult;
-    'page:context': (ctx: {
-        page: string;
-        localeCode: string;
-    }, utils: any, data: Record<string, any>) => HookResult;
     'page:chunks': (bundle: string, scripts: {
         head: string[];
         body: string[];
@@ -31,14 +27,11 @@ export interface FlowApp {
     callHook: FlowApp['hooks']['callHook'];
     eta: any;
     app: {
-        utils: FlowAppUtils;
+        utils: Record<string, any>;
         plugins: Record<string, any>;
         globals: Record<string, any>;
     };
     engine: string;
-    site: {
-        origin: string;
-    };
     engines: Record<string, (template: string) => string>;
     generate: boolean;
     render: (view: Record<string, string>, data: any) => Promise<string> | void | string;

package/dist/app/flow.mjs

@@ -20,9 +20,6 @@ export function createFlowApp({ runtimeConfig }) {
     },
     engine: "eta",
     engines: {},
-    site: {
-      origin: `${process.env.URL || "http://localhost"}`
-    },
     generate: runtimeConfig.generate
   };
   flowApp.engines.eta = (template) => {

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

@@ -1,6 +1,6 @@
-import "node-fetch-native/polyfill";
 import { defineEventHandler } from "h3";
-import { defineCachedFunction, useRuntimeConfig } from "#internal/nitro";
+import "node-fetch-native/polyfill";
+import { useRuntimeConfig } from "#internal/nitro";
 const getServerApp = cachedImport(() => import("#server"));
 const getFlowRenderer = cachedResult(async () => {
   const createFlowApp = await getServerApp();
@@ -12,7 +12,6 @@ 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,10 +1,4 @@
 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;
@@ -15,58 +9,35 @@ export default eventHandler(async (event) => {
   const scripts = { head: [], bodyStart: [], bodyEnd: [] };
   const chunks = { head: [], body: [] };
   const generate = {};
-  const { page, locale, params, view, name: pageName } = flow.router.byUrl.lookup(url) || {};
+  const { page, locale, params, view } = 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 dynamic = params?._;
-  const contextPage = {
-    chunks,
-    locale
-  };
+  const dynamyc = params?._;
+  const contextPage = {};
   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);
+  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value }, flow.app.utils);
   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 (dynamic && page.dynamic) {
+  if (dynamyc && page.dynamic) {
     const pages = await page.dynamic.method({ locale, utils });
-    const dynamicPage = pages.find((_page) => _page.url === dynamic);
+    const dynamicPage = pages.find((_page) => _page.url === dynamyc);
     if (!dynamicPage)
       return;
     if (page.dynamic.assign)
       templateContext[page.dynamic.assign] = dynamicPage.context;
-    contextPage.dynamic = dynamicPage;
+    contextPage.dynamyc = dynamicPage;
   }
   templateContext.seo = {};
-  const sharedContext = await utils.getSharedContext({
-    ...contextHooks,
-    ...contextPage,
-    utils
-  });
-  templateContext.sharedContext = sharedContext || {};
+  templateContext.context = {};
+  templateContext.sharedContext = {};
   templateContext.utils = utils;
-  templateContext.seo = await normalizeCall(page?.seo, { ...contextHooks, ...contextPage, utils, sharedContext });
-  const contexData = await page.context?.({ ...contextHooks, ...contextPage, utils, sharedContext }) || {};
-  templateContext.context = {
-    ...contextHooks,
-    ...contexData
-  };
+  templateContext.seo = await page.seo?.({ ...contextPage, utils }) || {};
+  templateContext.context = await page.context?.({ ...contextPage, utils }) || {};
   templateContext.getHeadScripts = () => {
     return scripts.head.join("\n");
   };
@@ -82,14 +53,8 @@ export default eventHandler(async (event) => {
   const query = useQuery(event);
   if (query?.context)
     return { ...templateContext, utils: Object.keys(utils) };
-  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);
+  const html = await flow.render(view, templateContext);
+  event.res.setHeader("Content-Type", "text/html;charset=UTF-8");
   if (flow.generate) {
     await flow.callHook("page:generate", generate);
     globalThis.generate = generate;

package/dist/index.mjs

@@ -1,12 +1,10 @@
 import { createHooks } from 'hookable';
 import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
 import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, useNuxt, resolveAlias, resolveFilesFlow, nuxtCtx, installModule, loadFlowConfig, templateUtils, normalizeTemplate, compileTemplate, normalizePlugin, isIgnoredFlow } from '@monkeyplus/flow-kit';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'node: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 fs from 'fs';
 import escapeRE from 'escape-string-regexp';
 import { camelCase, pascalCase } from 'scule';
 import { genImport, genDynamicImport, genArrayFromRaw, genString, genObjectFromRawEntries } from 'knitwork';
@@ -29,7 +27,7 @@ import { isExternal as isExternal$1, ExternalsDefaults } from 'externality';
 import { createHash } from 'node:crypto';
 import MagicString from 'magic-string';
 
-const version = "5.0.0-rc.79";
+const version = "5.0.0-rc.8";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -94,8 +92,7 @@ const commonPresets = [
     from: "#_pages",
     imports: [
       "definePage",
-      "defineDynamicPage",
-      "defineSharedContext"
+      "defineDinamycPage"
     ]
   })
 ];
@@ -227,24 +224,18 @@ function addDeclarationTemplates(ctx) {
   addTemplate({
     filename: "types/auto-imports.d.ts",
     getContents: () => `// Generated by auto imports
-${ctx.generateTypeDeclarations({ resolvePath: r })}`
+${ctx.generateTypeDecarations({ resolvePath: r })}`
   });
 }
 
-async function resolveFiles(dir) {
+async function resolvePagesRoutes() {
   const nuxt = useNuxt();
-  const dirs = [resolve(nuxt.options.srcDir, dir)];
-  const allRoutes = (await Promise.all(dirs.map(async (dir2) => {
-    const files = await resolveFilesFlow(dir2, `**/*{${nuxt.options.extensions.join(",")}}`);
+  const pagesDirs = [...new Set(nuxt.options._layers.map((layer) => resolve(layer.config.srcDir, layer.config.dir?.pages || "pages")))];
+  const allRoutes = (await Promise.all(pagesDirs.map(async (dir) => {
+    const files = await resolveFilesFlow(dir, `**/*{${nuxt.options.extensions.join(",")}}`);
     files.sort();
-    return files.filter((file) => {
-      if (file.includes(" copy"))
-        return false;
-      if (!fs.readFileSync(file, "utf8").includes("export"))
-        return false;
-      return true;
-    }).map((file) => {
-      const segments = relative(dir2, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
+    return files.map((file) => {
+      const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
       return {
         file,
         name: camelCase(segments)
@@ -253,31 +244,24 @@ async function resolveFiles(dir) {
   }))).flat();
   return allRoutes;
 }
-function normalizeExports(files) {
-  const imports = files.map((page) => genImport(page.file, page.name)).join("\n");
-  const exports = files.reduce((acc, curr) => {
-    const name = curr.name;
-    return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
-  }, "");
+function normalizePages(pages) {
+  const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
   return {
     imports,
-    exports
+    exports: pages.reduce((acc, curr) => {
+      const name = curr.name;
+      return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
+    }, "")
   };
 }
 
 const pagesTypeTemplate = {
-  filename: "types/pages.d.ts",
+  filename: "pages.d.ts",
   getContents: ({ options }) => `// Generated by pages discovery
 export {}
 declare global {
-  type ArrElement<ArrType> = ArrType extends readonly (infer ElementType)[]
-  ? ElementType
-  : never;
 
-${options.pages.map((c) => {
-    const _type = `ArrElement<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(join(options.buildDir, "types"), c.file) : c.file, { wrapper: false })}['default']>`;
-    return `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<${_type}['locales']['es-ec']['context']>>`;
-  }).join("\n")}
+${options.pages.map((c) => `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(options.buildDir, c.file) : c.file, { wrapper: false })}['pages']['locales']['es-ec']['context']>>`).join("\n")}
 }
 export const pagesNames: string[]
 `.replaceAll(".ts", "")
@@ -291,52 +275,37 @@ const pagesModule = defineNuxtModule({
     const runtimeDir = resolve(distDir, "pages/runtime");
     flow.options.alias["#_pages"] = runtimeDir;
     const pages = [];
-    const contexts = [];
-    const options = { pages, buildDir: flow.options.buildDir, contexts };
+    flow.hook("builder:watch", async (event, path) => {
+      const dirs = [
+        flow.options.dir.pages,
+        flow.options.dir.layouts,
+        flow.options.dir.middleware
+      ].filter(Boolean);
+      const pathPattern = new RegExp(`^(${dirs.map(escapeRE).join("|")})/`);
+      if (event !== "change" && path.match(pathPattern))
+        await flow.callHook("builder:generateApp");
+    });
+    const options = { pages, buildDir: flow.options.buildDir };
     addTemplate({
       ...pagesTypeTemplate,
       options
     });
-    const pagesDirs = [{ path: resolve(flow.options.srcDir, flow.options.dir.pages) }];
     flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
-    flow.options.alias["#pagesContexts"] = resolve(flow.options.buildDir, "pages.contexts.mjs");
     addTemplate({
       filename: "pages.mjs",
       async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.pages);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
-      },
-      options
-    });
-    addTemplate({
-      filename: "pages.contexts.mjs",
-      async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.contexts);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
+        const { exports, imports } = normalizePages(options2.pages);
+        return [imports, `export default {${exports}}`].join("\n");
       },
       options
     });
     flow.hook("app:templates", async () => {
-      options.pages = await resolveFiles(flow.options.dir?.pages || "pages");
-    });
-    flow.hook("app:templates", async () => {
-      options.contexts = await resolveFiles("shared/contexts");
+      options.pages = await resolvePagesRoutes();
     });
     flow.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(flow.options.buildDir, "types/pages.d.ts") });
-    });
-    flow.hook("builder:watch", async (event, path) => {
-      if (!["add", "unlink", "change"].includes(event))
-        return;
-      if (path.includes(" copy"))
-        return;
-      const fPath = resolve(flow.options.rootDir, path);
-      if (pagesDirs.find((dir) => fPath.startsWith(dir.path)))
-        await flow.callHook("builder:generateApp");
+      references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
     });
-    addPlugin(resolve(runtimeDir, "pages"));
+    addPlugin({ src: resolve(runtimeDir, "plugin") });
   }
 });
 
@@ -364,7 +333,7 @@ const createClient = async (flow) => {
     if (vite)
       vite?.ws?.send({ type: "full-reload" });
   };
-  const doReload = debounce(_doReload, 75);
+  const doReload = debounce(_doReload, 60);
   flow.hook("bundler:change", () => {
     doReload();
   });
@@ -375,11 +344,11 @@ const createClient = async (flow) => {
 };
 const builClient = async (flow) => {
   return await build$1({
-    base: flow.options.dev ? "/" : flow.options.app.baseURL,
     root: flow.options.rootDir,
     mode: "production",
     build: {
-      target: "es2015",
+      assetsDir: "scripts",
+      target: "es2017",
       outDir: ".vite",
       manifest: true
     }
@@ -420,27 +389,26 @@ const viteModule = defineFlowModule({
         }
       });
     } else {
-      const file = resolve(flow.options.rootDir, ".vite/manifest.json");
-      addTemplate({
-        filename: "viteManifest.mjs",
-        async getContents() {
-          return [
-            "import fs from 'fs';",
-            `export default ()=>{
-            const manifest =JSON.parse(fs.readFileSync("${file}", 'utf8'));
-            return {manifest,base:'${_options.dir}'}
-          }`
-          ].join("\n");
-        }
-      });
-      flow.hook("build:before", async () => {
+      flow.hook("modules:done", async () => {
         const start = Date.now();
         logger$1.info("Building client...");
         await builClient(flow);
+        const file = resolve(flow.options.rootDir, ".vite/manifest.json");
+        const manifest = await fse.readFile(file, "utf8");
         logger$1.success(`Client build in ${Date.now() - start}ms`);
+        addTemplate({
+          filename: "viteManifest.mjs",
+          async getContents() {
+            return [
+              "export default ()=>(",
+              manifest,
+              ")"
+            ].join("\n");
+          }
+        });
       });
       flow.hook("generate:before", async () => {
-        const files = resolve(flow.options.rootDir, ".vite/assets");
+        const files = resolve(flow.options.rootDir, ".vite/scripts");
         await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
       });
     }
@@ -494,7 +462,6 @@ async function initNitro(flow) {
       ...flow.options.runtimeConfig,
       app: {
         ...flow.options.runtimeConfig.app,
-        baseURL: flow.options.dev ? "/" : flow.options.app.baseURL,
         rootDir: flow.options.rootDir,
         locale: flow.options.locale
       },
@@ -522,8 +489,7 @@ async function initNitro(flow) {
     externals: {
       inline: [
         ...flow.options.dev ? [] : ["eta", "@monkeyplus/", "@vue/", "@nuxt/", flow.options.buildDir],
-        "@monkeyplus/flow/dist",
-        "C:/Users/gnu/Documents/GitHub/flow/packages/flow/dist/app"
+        "@monkeyplus/flow/dist"
       ]
     },
     alias: {
@@ -534,8 +500,7 @@ async function initNitro(flow) {
       ...flow.options.alias
     },
     rollupConfig: {
-      plugins: [],
-      external: [""]
+      plugins: []
     }
   });
   await flow.callHook("nitro:config", nitroConfig);
@@ -1127,8 +1092,6 @@ const buildServer = async (ctx) => {
         "/__vue-jsx",
         "#app",
         /(nuxt|nuxt3)\/(dist|src|app)/,
-        /flow\/(dist|src|app)/,
-        /flow\/modules\/(content|icons|images|netlify|netlify-cms|seo|sitemap|vue)/,
         /@monkeyplus\/flow\/(dist|src|app)/,
         /@nuxt\/nitro\/(dist|src)/
       ]
@@ -1206,11 +1169,9 @@ const buildServer = async (ctx) => {
     await onBuild();
     ctx.flow.callHook("bundler:change", {});
   };
-  const doBuild = debounce(_doBuild, 50);
+  const doBuild = debounce(_doBuild);
   await _doBuild();
   viteServer.watcher.on("all", (_event, file) => {
-    if (file.includes("/pages/"))
-      return;
     file = normalize(file);
     if (file.indexOf(ctx.flow.options.buildDir) === 0)
       return;
@@ -1330,7 +1291,6 @@ async function bundleVite(flow) {
         include: []
       },
       build: {
-        ssr: true,
         rollupOptions: {
           output: { sanitizeFileName: sanitizeFilePath },
           input: resolve(flow.options.appDir, "entry")
@@ -1367,8 +1327,6 @@ async function bundleVite(flow) {
   flow.hook("vite:serverCreated", (server) => {
     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:"))
           server.moduleGraph.invalidateModule(mod);
       }
@@ -1410,7 +1368,8 @@ function watch(flow) {
       "node_modules"
     ]
   });
-  watcher.on("all", (event, path) => flow.callHook("builder:watch", event, normalize(path)));
+  const watchHook = debounce((event, path) => flow.callHook("builder:watch", event, normalize(path)));
+  watcher.on("all", watchHook);
   flow.hook("close", () => watcher.close());
   return watcher;
 }

package/dist/pages/runtime/helpers/index.mjs

@@ -1,9 +1,6 @@
 import { joinURL, withTrailingSlash } from "ufo";
-const buildPages = (page) => (location, language, _locales) => {
-  const locales = _locales.map((key) => {
-    const _page = page.locales[key];
-    return [key, _page];
-  }).filter((el) => !!el[1]);
+const buildPages = (page) => (location, language) => {
+  const locales = Object.entries(page.locales);
   return locales.map(([locale, localePage]) => {
     const [_language, _location] = locale.split("-");
     const name = joinURL("/", _location, _language, page.name);

package/dist/pages/runtime/index.d.ts

@@ -1,10 +1,3 @@
-import type { DynamicPage, PageCtx, SimplePage } from '@monkeyplus/flow-schema';
-export declare function definePage<T>(...pages: SimplePage<T>[]): SimplePage<T>[];
-export declare function defineDynamicPage<T>(...pages: DynamicPage<T>[]): DynamicPage<T>[];
-export interface SharedContext {
-    assign?: 'global' | 'local';
-    merge?: boolean;
-    setup: (cxt: PageCtx) => any;
-    locales?: Record<string, (ctx: PageCtx) => any>;
-}
-export declare function defineSharedContext(shared: SharedContext): SharedContext;
+import type { DynamicPage, SimplePage } from '@monkeyplus/flow-schema';
+export declare function definePage(page: SimplePage): SimplePage;
+export declare function defineDinamycPage(page: DynamicPage): DynamicPage;

package/dist/pages/runtime/index.mjs

@@ -1,13 +1,6 @@
-export function definePage(...pages) {
-  return pages;
+export function definePage(page) {
+  return page;
 }
-export function defineDynamicPage(...pages) {
-  return pages.map((page) => {
-    if (!page.name.endsWith("/**"))
-      page.name = `${page.name}/**`;
-    return page;
-  });
-}
-export function defineSharedContext(shared) {
-  return shared;
+export function defineDinamycPage(page) {
+  return page;
 }

package/dist/pages/runtime/plugin.mjs

@@ -0,0 +1,56 @@
+import { joinURL } from "ufo";
+import consola from "consola";
+import { definePage } from "./helpers/index.mjs";
+import { defineFlowPlugin, useRuntimeConfig } from "#app";
+import pages from "#pages";
+export default defineFlowPlugin(async (flow) => {
+  const { app } = useRuntimeConfig();
+  const allPages = [];
+  const basePages = Object.entries(pages);
+  consola.success("Parsed %i pages", basePages.length);
+  basePages.forEach(([name, page]) => {
+    const { getPages } = definePage({
+      name,
+      ...page
+    });
+    const _pages = getPages(app.locale.location, app.locale.language);
+    _pages.forEach((page2) => {
+      flow.router.byUrl.insert(page2.url, page2.context);
+      flow.router.byName.insert(page2.name, page2.context);
+      allPages.push(page2.context);
+    });
+  });
+  function getUrl(namePage, localeCode) {
+    const code = localeCode || this?.getLocale()?.code;
+    const [lang, loc] = code.split("-");
+    const name = joinURL("/", loc, lang, namePage);
+    const { path } = flow.router.byName.lookup(name) || {};
+    return path || "/404";
+  }
+  async function getUrls(withLocale = false) {
+    const urls = [];
+    for (const page of allPages) {
+      if (!page.path.includes("/**")) {
+        urls.push(withLocale ? { url: page.path, locale: page.locale.code, name: page.name } : page.path);
+      } else {
+        const dPages = await page.page.dynamic.method({
+          locale: page.locale,
+          utils: Object.assign({ getLocale: () => page.locale }, flow.app.utils)
+        });
+        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);
+        });
+      }
+    }
+    return urls.sort();
+  }
+  flow.setUtil("getUrl", getUrl);
+  flow.setUtil("getUrls", getUrls);
+  flow.setUtil("getPages", () => allPages);
+  return {
+    provide: {
+      pages: { allPages }
+    }
+  };
+});

package/dist/vite-client/runtime/injectManifest.mjs

@@ -5,8 +5,7 @@ export const generateBundle = (config, bundle, _id) => {
     const chunks = [];
     chunk2.imports?.forEach((file) => {
       const importee = bundle[file];
-      const isChunk = file.startsWith("_") || importee.isEntry;
-      if (isChunk && !seen.has(file)) {
+      if (file.startsWith("_") && !seen.has(file)) {
         seen.add(file);
         chunks.push(...getImportedChunks(importee, seen));
         chunks.push(importee);
@@ -37,7 +36,7 @@ export const generateBundle = (config, bundle, _id) => {
       analyzedChunk.set(chunk2, 1);
       chunk2.imports?.forEach((file) => {
         const importee = bundle[file];
-        if (file.startsWith("_") || importee.isEntry)
+        if (file.startsWith("_"))
           tags.push(...getCssTagsForChunk(importee, publicBase2, seen));
       });
     }
@@ -72,7 +71,7 @@ export const generateBundle = (config, bundle, _id) => {
 export const externalRE = /^(https?:)?\/\//;
 export const isExternalUrl = (url) => externalRE.test(url);
 function toPublicPath(filename, publicBase) {
-  return isExternalUrl(filename) ? filename : joinURL(publicBase, filename);
+  return isExternalUrl(filename) ? filename : joinURL(publicBase, filename.replace("scripts", "assets"));
 }
 const unaryTags = new Set(["link", "meta", "base"]);
 function serializeTag({ tag, attrs, children }, indent = "") {

package/dist/vite-client/runtime/plugin.mjs

@@ -1,14 +1,13 @@
 import logger from "consola";
-import { joinURL } from "ufo";
 import { generateBundle } from "./injectManifest.mjs";
 import { defineFlowPlugin } from "#app";
 import manifest from "#viteManifest";
 export default defineFlowPlugin((flow) => {
   if (typeof manifest === "function") {
+    const _manifest = manifest();
     flow.hook("page:chunks", (bundle, chunks) => {
       try {
-        const data = manifest();
-        const chunk = generateBundle(flow.$config.app || {}, data.manifest, joinURL("/", data.base, `${bundle}.ts`).replace("/", ""));
+        const chunk = generateBundle(flow.$config.app || {}, _manifest, `client/pages/${bundle}.ts`);
         if (chunk) {
           chunks.head.push(chunk.head);
           chunks.body.push(chunk.body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.79",
+  "version": "5.0.0-rc.8",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -25,52 +25,52 @@
     "dist"
   ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.79",
-    "@monkeyplus/flow-kit": "5.0.0-rc.79",
-    "@monkeyplus/flow-schema": "5.0.0-rc.79",
+    "@monkeyplus/flow-cli": "5.0.0-rc.8",
+    "@monkeyplus/flow-kit": "5.0.0-rc.8",
+    "@monkeyplus/flow-schema": "5.0.0-rc.8",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
-    "c12": "^0.2.8",
+    "c12": "^0.2.7",
     "chokidar": "^3.5.3",
     "consola": "^2.15.3",
     "defu": "^6.0.0",
-    "esbuild": "^0.14.49",
+    "esbuild": "^0.14.38",
     "escape-string-regexp": "^5.0.0",
-    "esno": "^0.16.3",
+    "esno": "^0.14.1",
     "eta": "^1.12.3",
-    "externality": "^0.2.2",
+    "externality": "^0.2.1",
     "fs-extra": "^10.1.0",
     "get-port-please": "^2.5.0",
-    "globby": "^13.1.2",
-    "h3": "^0.7.10",
+    "globby": "^13.1.1",
+    "h3": "^0.7.4",
     "hookable": "^5.1.1",
-    "jiti": "^1.14.0",
-    "knitwork": "^0.1.2",
-    "listhen": "^0.2.13",
+    "jiti": "^1.13.0",
+    "knitwork": "^0.1.1",
+    "listhen": "^0.2.10",
     "magic-string": "^0.26.2",
-    "mlly": "^0.5.4",
+    "mlly": "^0.5.2",
     "mri": "^1.2.0",
-    "nitropack": "^0.4.12",
-    "pathe": "^0.3.2",
+    "nitropack": "^0.4.4",
+    "pathe": "^0.2.0",
     "perfect-debounce": "^0.1.3",
     "radix3": "^0.1.2",
     "unenv": "^0.5.2",
     "ohmyfetch": "^0.4.18",
-    "node-fetch-native": "^0.1.4",
-    "rollup": "^2.77.0",
-    "rollup-plugin-visualizer": "^5.7.1",
+    "node-fetch-native": "^0.1.3",
+    "rollup": "^2.72.1",
+    "rollup-plugin-visualizer": "^5.6.0",
     "scule": "^0.2.1",
-    "ufo": "^0.8.5",
+    "ufo": "^0.8.3",
     "unctx": "^1.1.4",
-    "unimport": "^0.4.5",
-    "unplugin": "^0.7.2",
+    "unimport": "^0.2.1",
+    "unplugin": "^0.6.3",
     "untyped": "^0.4.4",
     "vite": "^2.9.9",
-    "vue": "^3.2.37"
+    "vue": "^3.2.33"
   },
   "devDependencies": {
     "@types/fs-extra": "^9.0.13",
-    "vue-router": "^4.1.2"
+    "vue-router": "^4.0.15"
   },
   "engines": {
     "node": "^16.11.0 || ^17.0.0 || ^18.0.0"

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 }
-    }
-  };
-});