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

package/dist/app/flow.d.ts

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

package/dist/index.mjs

@@ -1,10 +1,12 @@
 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, pathToFileURL } from 'node:url';
+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 fs from 'fs';
 import escapeRE from 'escape-string-regexp';
 import { camelCase, pascalCase } from 'scule';
 import { genImport, genDynamicImport, genArrayFromRaw, genString, genObjectFromRawEntries } from 'knitwork';
@@ -27,7 +29,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.8";
+const version = "5.0.0-rc.81";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -92,7 +94,8 @@ const commonPresets = [
     from: "#_pages",
     imports: [
       "definePage",
-      "defineDinamycPage"
+      "defineDynamicPage",
+      "defineSharedContext"
     ]
   })
 ];
@@ -224,18 +227,24 @@ function addDeclarationTemplates(ctx) {
   addTemplate({
     filename: "types/auto-imports.d.ts",
     getContents: () => `// Generated by auto imports
-${ctx.generateTypeDecarations({ resolvePath: r })}`
+${ctx.generateTypeDeclarations({ resolvePath: r })}`
   });
 }
 
-async function resolvePagesRoutes() {
+async function resolveFiles(dir) {
   const nuxt = useNuxt();
-  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(",")}}`);
+  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(",")}}`);
     files.sort();
-    return files.map((file) => {
-      const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
+    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 {
         file,
         name: camelCase(segments)
@@ -244,24 +253,31 @@ async function resolvePagesRoutes() {
   }))).flat();
   return allRoutes;
 }
-function normalizePages(pages) {
-  const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
+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}`;
+  }, "");
   return {
     imports,
-    exports: pages.reduce((acc, curr) => {
-      const name = curr.name;
-      return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
-    }, "")
+    exports
   };
 }
 
 const pagesTypeTemplate = {
-  filename: "pages.d.ts",
+  filename: "types/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) => `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")}
+${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")}
 }
 export const pagesNames: string[]
 `.replaceAll(".ts", "")
@@ -275,37 +291,52 @@ const pagesModule = defineNuxtModule({
     const runtimeDir = resolve(distDir, "pages/runtime");
     flow.options.alias["#_pages"] = runtimeDir;
     const pages = [];
-    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 };
+    const contexts = [];
+    const options = { pages, buildDir: flow.options.buildDir, contexts };
     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 } = normalizePages(options2.pages);
-        return [imports, `export default {${exports}}`].join("\n");
+        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;
       },
       options
     });
     flow.hook("app:templates", async () => {
-      options.pages = await resolvePagesRoutes();
+      options.pages = await resolveFiles(flow.options.dir?.pages || "pages");
+    });
+    flow.hook("app:templates", async () => {
+      options.contexts = await resolveFiles("shared/contexts");
     });
     flow.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
+      references.push({ path: resolve(flow.options.buildDir, "types/pages.d.ts") });
     });
-    addPlugin({ src: resolve(runtimeDir, "plugin") });
+    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");
+    });
+    addPlugin(resolve(runtimeDir, "pages"));
   }
 });
 
@@ -333,7 +364,7 @@ const createClient = async (flow) => {
     if (vite)
       vite?.ws?.send({ type: "full-reload" });
   };
-  const doReload = debounce(_doReload, 60);
+  const doReload = debounce(_doReload, 75);
   flow.hook("bundler:change", () => {
     doReload();
   });
@@ -344,11 +375,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: {
-      assetsDir: "scripts",
-      target: "es2017",
+      target: "es2015",
       outDir: ".vite",
       manifest: true
     }
@@ -389,26 +420,27 @@ const viteModule = defineFlowModule({
         }
       });
     } else {
-      flow.hook("modules:done", async () => {
+      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 () => {
         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/scripts");
+        const files = resolve(flow.options.rootDir, ".vite/assets");
         await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
       });
     }
@@ -462,6 +494,7 @@ 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
       },
@@ -489,7 +522,8 @@ async function initNitro(flow) {
     externals: {
       inline: [
         ...flow.options.dev ? [] : ["eta", "@monkeyplus/", "@vue/", "@nuxt/", flow.options.buildDir],
-        "@monkeyplus/flow/dist"
+        "@monkeyplus/flow/dist",
+        "C:/Users/gnu/Documents/GitHub/flow/packages/flow/dist/app"
       ]
     },
     alias: {
@@ -500,7 +534,8 @@ async function initNitro(flow) {
       ...flow.options.alias
     },
     rollupConfig: {
-      plugins: []
+      plugins: [],
+      external: [""]
     }
   });
   await flow.callHook("nitro:config", nitroConfig);
@@ -1092,6 +1127,8 @@ 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)/
       ]
@@ -1169,9 +1206,11 @@ const buildServer = async (ctx) => {
     await onBuild();
     ctx.flow.callHook("bundler:change", {});
   };
-  const doBuild = debounce(_doBuild);
+  const doBuild = debounce(_doBuild, 50);
   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;
@@ -1291,6 +1330,7 @@ async function bundleVite(flow) {
         include: []
       },
       build: {
+        ssr: true,
         rollupOptions: {
           output: { sanitizeFileName: sanitizeFilePath },
           input: resolve(flow.options.appDir, "entry")
@@ -1327,6 +1367,8 @@ 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);
       }
@@ -1368,8 +1410,7 @@ function watch(flow) {
       "node_modules"
     ]
   });
-  const watchHook = debounce((event, path) => flow.callHook("builder:watch", event, normalize(path)));
-  watcher.on("all", watchHook);
+  watcher.on("all", (event, path) => flow.callHook("builder:watch", event, normalize(path)));
   flow.hook("close", () => watcher.close());
   return watcher;
 }

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

@@ -1,6 +1,9 @@
 import { joinURL, withTrailingSlash } from "ufo";
-const buildPages = (page) => (location, language) => {
-  const locales = Object.entries(page.locales);
+const buildPages = (page) => (location, language, _locales) => {
+  const locales = _locales.map((key) => {
+    const _page = page.locales[key];
+    return [key, _page];
+  }).filter((el) => !!el[1]);
   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,3 +1,10 @@
-import type { DynamicPage, SimplePage } from '@monkeyplus/flow-schema';
-export declare function definePage(page: SimplePage): SimplePage;
-export declare function defineDinamycPage(page: DynamicPage): DynamicPage;
+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;

package/dist/pages/runtime/index.mjs

@@ -1,6 +1,13 @@
-export function definePage(page) {
-  return page;
+export function definePage(...pages) {
+  return pages;
 }
-export function defineDinamycPage(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;
 }

package/dist/pages/runtime/pages.mjs

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

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

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

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

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

package/dist/pages/runtime/plugin.mjs

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