@monkeyplus/flow 5.0.0-rc.3 → 5.0.0-rc.30

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;
@@ -27,7 +27,7 @@ export interface FlowApp {
     callHook: FlowApp['hooks']['callHook'];
     eta: any;
     app: {
-        utils: Record<string, any>;
+        utils: FlowAppUtils;
         plugins: Record<string, any>;
         globals: Record<string, any>;
     };

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

@@ -16,27 +16,32 @@ export default eventHandler(async (event) => {
   if (view.bundle)
     await flow.callHook("page:chunks", view.bundle, chunks);
   const templateContext = {};
-  const dynamyc = params?._;
-  const contextPage = {};
-  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  const dynamic = params?._;
+  const contextPage = {
+    chunks,
+    locale
+  };
+  const contextInject = {};
+  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value, defineCachedFunction: event.context.defineCachedFunction }, flow.app.utils);
   templateContext.url = url;
   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(utils);
+  templateContext.sharedContext = sharedContext || {};
   templateContext.utils = utils;
-  templateContext.seo = await page.seo?.({ ...contextPage, utils }) || {};
-  templateContext.context = await page.context?.({ ...contextPage, utils }) || {};
+  templateContext.seo = await page.seo?.({ ...contextPage, utils, sharedContext }) || {};
+  templateContext.context = await page.context?.({ ...contextPage, utils, sharedContext }) || {};
   templateContext.getHeadScripts = () => {
     return scripts.head.join("\n");
   };
@@ -46,11 +51,20 @@ export default eventHandler(async (event) => {
   templateContext.getBodyChunks = () => {
     return chunks.body.join("\n");
   };
+  templateContext.getInjectContext = () => {
+    return `<script id="__FLOW_DATA__" type="application/json">${JSON.stringify(contextInject)}<\/script>`;
+  };
   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.3";
+const version = "5.0.0-rc.30";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -87,6 +89,14 @@ const commonPresets = [
     imports: [
       "useHead"
     ]
+  }),
+  defineUnimportPreset({
+    from: "#_pages",
+    imports: [
+      "definePage",
+      "defineDinamycPage",
+      "defineSharedContext"
+    ]
   })
 ];
 const appPreset = defineUnimportPreset({
@@ -221,14 +231,20 @@ ${ctx.generateTypeDecarations({ 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)
@@ -237,21 +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) => `${curr.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", "")
@@ -263,38 +289,54 @@ const pagesModule = defineNuxtModule({
   },
   async setup(_options, flow) {
     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 resolveFiles(flow.options.dir?.pages || "pages");
+    });
     flow.hook("app:templates", async () => {
-      options.pages = await resolvePagesRoutes();
+      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"));
   }
 });
 
@@ -322,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();
   });
@@ -378,23 +420,24 @@ 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");
@@ -478,7 +521,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: {
@@ -489,7 +533,8 @@ async function initNitro(flow) {
       ...flow.options.alias
     },
     rollupConfig: {
-      plugins: []
+      plugins: [],
+      external: [""]
     }
   });
   await flow.callHook("nitro:config", nitroConfig);
@@ -1081,6 +1126,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)/
       ]
@@ -1158,9 +1205,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;
@@ -1280,6 +1329,7 @@ async function bundleVite(flow) {
         include: []
       },
       build: {
+        ssr: true,
         rollupOptions: {
           output: { sanitizeFileName: sanitizeFilePath },
           input: resolve(flow.options.appDir, "entry")
@@ -1316,6 +1366,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.mjs"))
+          server.moduleGraph.invalidateModule(mod);
         if (id.startsWith("\0virtual:"))
           server.moduleGraph.invalidateModule(mod);
       }
@@ -1357,8 +1409,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/index.d.ts

@@ -1,3 +1,9 @@
-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 defineDinamycPage<T>(...pages: DynamicPage<T>[]): DynamicPage<T>[];
+interface SharedContext {
+    assign?: 'global' | 'local';
+    setup: (cxt: PageCtx) => any;
+}
+export declare function defineSharedContext(shared: SharedContext): SharedContext;
+export {};

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 defineDinamycPage(...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,90 @@
+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);
+      _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: {}
+        });
+        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(utils) {
+    const entries = Object.entries(contexts);
+    if (!entries.length)
+      return {};
+    const _contexts = await Promise.all(entries.map(async ([key, method]) => {
+      const data = await method.setup(utils);
+      return { [key]: data };
+    }));
+    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/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.3",
+  "version": "5.0.0-rc.30",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -25,9 +25,9 @@
     "dist"
   ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.3",
-    "@monkeyplus/flow-kit": "5.0.0-rc.3",
-    "@monkeyplus/flow-schema": "5.0.0-rc.3",
+    "@monkeyplus/flow-cli": "5.0.0-rc.30",
+    "@monkeyplus/flow-kit": "5.0.0-rc.30",
+    "@monkeyplus/flow-schema": "5.0.0-rc.30",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
     "c12": "^0.2.7",
@@ -50,7 +50,7 @@
     "magic-string": "^0.26.2",
     "mlly": "^0.5.2",
     "mri": "^1.2.0",
-    "nitropack": "^0.4.4",
+    "nitropack": "^0.4.8",
     "pathe": "^0.2.0",
     "perfect-debounce": "^0.1.3",
     "radix3": "^0.1.2",

package/dist/pages/runtime/plugin.mjs

@@ -1,53 +0,0 @@
-import { joinURL } from "ufo";
-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 = [];
-  Object.entries(pages).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 }
-    }
-  };
-});