@monkeyplus/flow 5.0.0-rc.2 → 5.0.0-rc.20

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

@@ -1,5 +1,5 @@
-import { defineEventHandler } from "h3";
 import "node-fetch-native/polyfill";
+import { defineEventHandler } from "h3";
 import { useRuntimeConfig } from "#internal/nitro";
 const getServerApp = cachedImport(() => import("#server"));
 const getFlowRenderer = cachedResult(async () => {

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

@@ -1,4 +1,5 @@
 import { eventHandler, useQuery } from "h3";
+import { defineCachedFunction } from "#internal/nitro";
 export default eventHandler(async (event) => {
   const url = event.req.url?.split("?")[0];
   const flow = event.context.flow;
@@ -16,20 +17,21 @@ export default eventHandler(async (event) => {
   if (view.bundle)
     await flow.callHook("page:chunks", view.bundle, chunks);
   const templateContext = {};
-  const dynamyc = params?._;
+  const dynamic = params?._;
   const contextPage = {};
-  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  const contextInject = {};
+  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value, 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 = {};
@@ -46,11 +48,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

@@ -27,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.2";
+const version = "5.0.0-rc.20";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -87,6 +87,13 @@ const commonPresets = [
     imports: [
       "useHead"
     ]
+  }),
+  defineUnimportPreset({
+    from: "#_pages",
+    imports: [
+      "definePage",
+      "defineDinamycPage"
+    ]
   })
 ];
 const appPreset = defineUnimportPreset({
@@ -223,11 +230,11 @@ ${ctx.generateTypeDecarations({ resolvePath: r })}`
 
 async function resolvePagesRoutes() {
   const nuxt = useNuxt();
-  const pagesDirs = [...new Set(nuxt.options._layers.map((layer) => resolve(layer.config.srcDir, layer.config.dir?.pages || "pages")))];
+  const pagesDirs = [resolve(nuxt.options.srcDir, nuxt.options.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.map((file) => {
+    return files.filter((file) => !file.includes(" copy")).map((file) => {
       const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
       return {
         file,
@@ -241,7 +248,10 @@ function normalizePages(pages) {
   const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
   return {
     imports,
-    exports: pages.reduce((acc, curr) => `${curr.name || ""},${acc}`, "")
+    exports: pages.reduce((acc, curr) => {
+      const name = curr.name;
+      return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
+    }, "")
   };
 }
 
@@ -263,22 +273,14 @@ 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 };
     addTemplate({
       ...pagesTypeTemplate,
       options
     });
+    const pagesDirs = [{ path: resolve(flow.options.srcDir, flow.options.dir.pages) }];
     flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
     addTemplate({
       filename: "pages.mjs",
@@ -294,6 +296,15 @@ const pagesModule = defineNuxtModule({
     flow.hook("prepare:types", ({ references }) => {
       references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
     });
+    flow.hook("builder:watch", async (event, path) => {
+      if (!["add", "unlink"].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({ src: resolve(runtimeDir, "plugin") });
   }
 });
@@ -378,23 +389,21 @@ 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 ()=>JSON.parse(fs.readFileSync("${file}", 'utf8'))`
+          ].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");
@@ -486,7 +495,6 @@ async function initNitro(flow) {
       "@babel/parser": "unenv/runtime/mock/proxy",
       "#paths": resolve(distDir, "core/runtime/nitro/paths"),
       "#server": "#build/dist/server/server.mjs",
-      "#app": flow.options.appDir,
       ...flow.options.alias
     },
     rollupConfig: {
@@ -630,6 +638,7 @@ async function initFlow(flow) {
 async function loadFlow(opts) {
   const options = await loadFlowConfig(opts);
   options.appDir = resolve(distDir, "app");
+  options.alias["#app"] = resolve(distDir, "app/index");
   options._majorVersion = 3;
   options._modules.push(pagesModule, metaModule, autoImportsModule, viteModule);
   options.modulesDir.push(resolve(pkgDir, "node_modules"));
@@ -1158,7 +1167,7 @@ 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) => {
     file = normalize(file);

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

@@ -1,3 +1,3 @@
 import type { DynamicPage, SimplePage } from '@monkeyplus/flow-schema';
-export declare function definePage(page: SimplePage): SimplePage;
-export declare function defineDinamycPage(page: DynamicPage): DynamicPage;
+export declare function definePage(...pages: SimplePage[]): SimplePage[];
+export declare function defineDinamycPage(...pages: DynamicPage[]): DynamicPage[];

package/dist/pages/runtime/index.mjs

@@ -1,6 +1,10 @@
-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;
+  });
 }

package/dist/pages/runtime/plugin.mjs

@@ -1,27 +1,45 @@
 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 = [];
-  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);
+  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);
+      });
     });
   });
-  function getUrl(namePage, localeCode) {
+  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 } = flow.router.byName.lookup(name) || {};
+    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) {

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

@@ -4,10 +4,9 @@ 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 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,22 +1,33 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.2",
+  "version": "5.0.0-rc.20",
   "license": "MIT",
   "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./types.d.ts",
+  "bin": {
+    "flow": "./bin/flow.mjs"
+  },
   "exports": {
     ".": "./dist/index.mjs",
     "./app": "./dist/app/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "types": "./types.d.ts",
-  "bin": {
-    "flow": "./bin/flow.mjs"
+  "imports": {
+    "#app": "./dist/app/index.mjs",
+    "#head": "./dist/head/runtime/index.mjs",
+    "#pages": "./dist/pages/runtime/index.mjs"
   },
+  "files": [
+    "app.d.ts",
+    "bin",
+    "types.d.ts",
+    "dist"
+  ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.2",
-    "@monkeyplus/flow-kit": "5.0.0-rc.2",
-    "@monkeyplus/flow-schema": "5.0.0-rc.2",
+    "@monkeyplus/flow-cli": "5.0.0-rc.20",
+    "@monkeyplus/flow-kit": "5.0.0-rc.20",
+    "@monkeyplus/flow-schema": "5.0.0-rc.20",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
     "c12": "^0.2.7",

package/build.config.ts

@@ -1,25 +0,0 @@
-import type { BuildEntry } from 'unbuild';
-import { defineBuildConfig } from 'unbuild';
-
-export default defineBuildConfig({
-  declaration: true,
-  entries: [
-    'src/index',
-    { input: 'src/app/', outDir: 'dist/app/' },
-    ...[
-      'core',
-      'head',
-      'pages',
-      'vite-client',
-    ].map((name) => ({ input: `src/${name}/runtime/`, outDir: `dist/${name}/runtime`, format: 'esm' } as BuildEntry)),
-    // { input: 'src/runtime/', outDir: 'dist/runtime', format: 'esm' },
-  ],
-  dependencies: [
-    '@monkeyplus/flow-cli',
-    'ohmyfetch',
-
-  ],
-  externals: [
-
-  ],
-});

package/src/app/composables/index.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-//* fake to nuxt Compatibilities
-import type { RouteLocationNormalizedLoaded } from 'vue-router';
-export function useCookie(name: string, _opts?: any) {
-  // console.log('Cookie', name, _opts);
-
-  return {};
-}
-
-export function refreshNuxtData(keys?: string | string[]): Promise<void> {
-  return Promise.resolve();
-}
-
-export function useAsyncData(key: string, handlers: () => Promise<any>) {
-  return handlers();
-}
-
-export function useRoute(): RouteLocationNormalizedLoaded {
-  return {} as any;
-}

package/src/app/entry.ts

@@ -1,36 +0,0 @@
-
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-import { config, configure, render } from 'eta';
-import { applyPlugins, createFlowApp } from './flow';
-// @ts-ignore
-import plugins from '#build/plugins';
-
-export default async(runtimeConfig: RuntimeConfig) => {
-  const flow = createFlowApp({ runtimeConfig });
-  try {
-    await applyPlugins(flow, plugins);
-    // console.log(flow.eta);
-
-    configure(flow.eta);
-    flow.render = (view: Record<string, string>, data: any) => {
-      // eslint-disable-next-line no-template-curly-in-string
-      const layout = '<%layout(`layouts/${it.view?.layout||\'default\'}`)%>';
-      const getTemplate = flow.engines[view.engine || flow.engine];
-      const base = `${layout}
-      ${getTemplate(view.template)}`;
-      return render(base, data || {}, {
-        ...config,
-        async: true,
-      });
-    };
-
-    // await flow.hooks.callHook('app:created', vueApp);
-  }
-  catch (err) {
-    console.log(err);
-    // await flow.callHook('app:error', err);
-    // ssrContext.error = ssrContext.error || err;
-  }
-
-  return flow;
-};

package/src/app/flow.ts

@@ -1,157 +0,0 @@
-import type { RadixRouter } from 'radix3';
-import { createRouter } from 'radix3';
-import type { Hookable } from 'hookable';
-import { createHooks } from 'hookable';
-import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
-import { getContext } from 'unctx';
-import { globby } from 'globby';
-import { join, resolve } from 'pathe';
-
-const flowAppCtx = getContext<FlowApp>('flow-app');
-
-type HookResult = Promise<void> | void;
-export interface FlowAppHooks{
-  'flow:pages': (page: FlowPage[]) => HookResult
-  'eta:plugin': (options: any) => HookResult
-  'page:scripts': (scripts: { head: string[]; bodyEnd: string[]; bodyStart: string[] }) => HookResult
-  'page:links': (links: string[]) => HookResult
-  'page:chunks': (bundle: string, scripts: { head: string[]; body: string[] }) => HookResult
-  'page:generate': (generate: any) => HookResult
-
-}
-export interface FlowApp {
-  router: { byUrl: RadixRouter<FlowPage['context']>; byName: RadixRouter<FlowPage['context']> }
-  hooks: Hookable<FlowAppHooks>
-  hook: FlowApp['hooks']['hook']
-  callHook: FlowApp['hooks']['callHook']
-  eta: any
-  app: {
-    utils: Record<string, any>
-    plugins: Record<string, any>
-    globals: Record<string, any>
-  }
-  engine: string
-
-  engines: Record<string, (template: string) => string>
-  generate: boolean
-  render: (view: Record<string, string>, data: any) => Promise<string>|void|string
-  provide: (name: string, value: any) => void
-  setUtil: (name: string, value: any) => void
-
-  [key: string]: any
-
-}
-
-export const FlowPluginIndicator = '__flow_plugin';
-export const NuxtPluginIndicator = '__nuxt_plugin';
-
-export interface Plugin<Injections extends Record<string, any> = Record<string, any>> {
-  (flow: FlowApp): Promise<void> | Promise<{ provide?: Injections }> | void | { provide?: Injections }
-  [FlowPluginIndicator]?: true
-}
-interface OptionsApp {
-  runtimeConfig: RuntimeConfig
-}
-
-export function createFlowApp({ runtimeConfig }: OptionsApp): FlowApp {
-  //
-
-  const viewsDir = join(runtimeConfig.app.rootDir, 'views');
-
-  const flowApp: FlowApp = {
-    router: { byUrl: createRouter(), byName: createRouter() },
-    app: {
-      utils: {},
-      globals: {},
-    },
-    eta: {
-      views: viewsDir,
-      plugins: [],
-    },
-    engine: 'eta',
-    engines: { },
-    generate: runtimeConfig.generate,
-  } as FlowApp;
-
-  flowApp.engines.eta = (template: string) => {
-    return `<%~ await includeFile('templates/${template}',it) %>`;
-  };
-  flowApp.hooks = createHooks<FlowAppHooks>();
-  flowApp.hook = flowApp.hooks.hook;
-  flowApp.callHook = flowApp.hooks.callHook;
-
-  flowApp.provide = (name: string, value: any) => {
-    const $name = `$${name}`;
-    defineGetter(flowApp, $name, value);
-    // defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
-  };
-  flowApp.setUtil = (name: string, method: any) => {
-    flowApp.app.utils[name] = method;
-  };
-
-  flowApp.hook('eta:plugin', (_plugin) => {
-    flowApp.eta.plugins.push(_plugin);
-  });
-
-  flowApp.provide('config', runtimeConfig);
-
-  return flowApp;
-}
-
-export function defineFlowPlugin<T>(plugin: Plugin<T>) {
-  plugin[FlowPluginIndicator] = true;
-  return plugin;
-}
-
-export function defineNuxtPlugin<T>(plugin: Plugin<T>) {
-  plugin[NuxtPluginIndicator] = true;
-  return plugin;
-}
-
-export async function applyPlugin(flowApp: FlowApp, plugin: Plugin) {
-  if (typeof plugin !== 'function') return;
-  const { provide } = await callWithFlow(flowApp, plugin, [flowApp]) || {};
-  if (provide && typeof provide === 'object') {
-    for (const key in provide)
-      flowApp.provide(key, provide[key]);
-  }
-}
-export async function applyPlugins(flowApp: FlowApp, plugins: Plugin[]) {
-  for (const plugin of plugins)
-    await applyPlugin(flowApp, plugin);
-}
-
-/**
- * Ensures that the setup function passed in has access to the Nuxt instance via `useNuxt`.
- *
- * @param flow A Flow instance
- * @param setup The function to call
- */
-export function callWithFlow<T extends(...args: any[]) => any> (flow: FlowApp, setup: T, args?: Parameters<T>) {
-  const fn = () => args ? setup(...args as Parameters<T>) : setup();
-  // TODO: posible error
-  flowAppCtx.set(flow);
-  return flowAppCtx.callAsync<ReturnType<T>>(flow, fn);
-}
-/**
- * Returns the current Nuxt instance.
- */
-export function useFlowApp() {
-  const flowAppInstance = flowAppCtx.use();
-  if (!flowAppInstance)
-    throw new Error('flow instance unavailable');
-
-  return flowAppInstance;
-}
-export function useRuntimeConfig(): RuntimeConfig {
-  return useFlowApp().$config;
-}
-
-function defineGetter<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, val: V) {
-  Object.defineProperty(obj, key, { get: () => val });
-}
-
-export async function resolveFiles(path: string, pattern: string | string[]) {
-  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
-  return files.filter((file) => !file.includes('copy.ts')).map((p) => resolve(path, p));
-}

package/src/app/index.ts

@@ -1,5 +0,0 @@
-export * from './flow';
-export * from './composables';
-
-// @ts-ignore
-export { useHead } from '#head';