@monkeyplus/flow 5.0.0-beta.9 → 5.0.0-rc.10

package/dist/app/composables/index.d.ts

@@ -1,4 +1,5 @@
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
 export declare function useCookie(name: string, _opts?: any): {};
 export declare function refreshNuxtData(keys?: string | string[]): Promise<void>;
 export declare function useAsyncData(key: string, handlers: () => Promise<any>): Promise<any>;
-export declare function useRoute(): {};
+export declare function useRoute(): RouteLocationNormalizedLoaded;

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

@@ -18,7 +18,8 @@ export default eventHandler(async (event) => {
   const templateContext = {};
   const dynamyc = 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 }, flow.app.utils);
   templateContext.url = url;
   templateContext.locale = locale;
   templateContext.view = view;
@@ -46,6 +47,9 @@ 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) };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createHooks } from 'hookable';
 import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
-import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, useNuxt, resolveAlias, resolveFiles, nuxtCtx, installModule, loadFlowConfig, templateUtils, normalizeTemplate, compileTemplate, normalizePlugin, resolveFilesFlow, isIgnoredFlow } from '@monkeyplus/flow-kit';
+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 { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
 import { createUnplugin } from 'unplugin';
@@ -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-beta.9";
+const version = "5.0.0-rc.10";
 
 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 resolveFiles(dir, `**/*{${nuxt.options.extensions.join(",")}}`);
+    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,6 +273,7 @@ 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 = [
@@ -279,6 +290,7 @@ const pagesModule = defineNuxtModule({
       ...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,34 +306,47 @@ 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;
+      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") });
   }
 });
 
 const createClient = async (flow) => {
-  const vite = await createServer({
-    root: resolve(flow.options.rootDir),
-    base: "/_vite/",
-    build: {
-      manifest: true
-    },
-    server: {
-      watch: {
-        ignored: ["**/.env/**", "**/.env*"]
+  let vite;
+  if (globalThis.viteClient) {
+    vite = globalThis.viteClient;
+  } else {
+    vite = await createServer({
+      root: resolve(flow.options.rootDir),
+      base: "/_vite/",
+      build: {
+        manifest: true
       },
-      middlewareMode: "ssr"
-    }
-  });
+      server: {
+        watch: {
+          ignored: ["**/.env/**", "**/.env*"]
+        },
+        middlewareMode: "ssr"
+      }
+    });
+    globalThis.viteClient = vite;
+  }
   const _doReload = () => {
     if (vite)
       vite?.ws?.send({ type: "full-reload" });
   };
-  const doReload = debounce(_doReload, 50);
+  const doReload = debounce(_doReload, 60);
   flow.hook("bundler:change", () => {
     doReload();
   });
   flow.hook("close", async () => {
-    await vite.close();
+    vite.restart();
   });
   return vite;
 };
@@ -340,10 +365,12 @@ const builClient = async (flow) => {
 
 const viteModule = defineFlowModule({
   meta: {
-    name: "viteClient"
+    name: "vite-client",
+    configKey: "bundle"
   },
   defaults: {
-    route: "/_vite/"
+    route: "/_vite/",
+    dir: "/client/pages"
   },
   async setup(_options, flow) {
     const runtimeDir = resolve(distDir, "vite-client/runtime");
@@ -362,9 +389,9 @@ const viteModule = defineFlowModule({
         async getContents() {
           return [
             "export default {",
-            'head:()=>`<script type="module" src="/_vite/@vite/client"><\/script>`',
+            `head:()=>'<script type="module" src="${joinURL("/", _options.route, "/@vite/client")}"><\/script>'`,
             ",",
-            'body: (bundle)=>`<script type="module" src="/_vite/client/pages/${bundle}.ts"><\/script>`',
+            `body: (bundle)=>\`<script type="module" src="${joinURL("/", _options.route, _options.dir)}/\${bundle}.ts"><\/script>\``,
             "}"
           ].join("\n");
         }
@@ -478,7 +505,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: {
@@ -622,6 +648,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"));
@@ -1095,10 +1122,7 @@ const buildServer = async (ctx) => {
     },
     server: {
       preTransformRequests: false,
-      cors: true,
-      watch: {
-        ignored: ["**/.env*"]
-      }
+      cors: true
     },
     plugins: [
       cacheDirPlugin(ctx.flow.options.rootDir, "server")
@@ -1153,7 +1177,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);
@@ -1347,6 +1371,7 @@ function watch(flow) {
     cwd: flow.options.srcDir,
     ignoreInitial: true,
     ignored: [
+      isIgnoredFlow,
       ".flow",
       "node_modules"
     ]

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

@@ -16,7 +16,7 @@ const buildPages = (page) => (location, language) => {
     return {
       name,
       url: path,
-      context: { page: localePage, locale: _locale, path, view: page.view, name }
+      context: { page: localePage, locale: _locale, path, view: page.view, name: page.name }
     };
   });
 };

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

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

package/dist/pages/runtime/index.mjs

@@ -0,0 +1,6 @@
+export function definePage(...pages) {
+  return pages;
+}
+export function defineDinamycPage(...pages) {
+  return pages;
+}

package/dist/pages/runtime/plugin.mjs

@@ -1,20 +1,26 @@
 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) {
@@ -24,18 +30,19 @@ export default defineFlowPlugin(async (flow) => {
     const { path } = flow.router.byName.lookup(name) || {};
     return path || "/404";
   }
-  async function getUrls() {
+  async function getUrls(withLocale = false) {
     const urls = [];
     for (const page of allPages) {
       if (!page.path.includes("/**")) {
-        urls.push(page.path);
+        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) => {
-          urls.push(joinURL(page.path.replace("/**", ""), dPage.url));
+          const _path = joinURL(page.path.replace("/**", ""), dPage.url);
+          urls.push(withLocale ? { url: _path, locale: page.locale.code, name: joinURL(page.name, dPage.name) } : _path);
         });
       }
     }
@@ -43,6 +50,7 @@ export default defineFlowPlugin(async (flow) => {
   }
   flow.setUtil("getUrl", getUrl);
   flow.setUtil("getUrls", getUrls);
+  flow.setUtil("getPages", () => allPages);
   return {
     provide: {
       pages: { allPages }

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-beta.9",
+  "version": "5.0.0-rc.10",
   "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-beta.9",
-    "@monkeyplus/flow-kit": "5.0.0-beta.9",
-    "@monkeyplus/flow-schema": "5.0.0-beta.9",
-    "@nuxt/vite-builder": "3.0.0-rc.1",
+    "@monkeyplus/flow-cli": "5.0.0-rc.10",
+    "@monkeyplus/flow-kit": "5.0.0-rc.10",
+    "@monkeyplus/flow-schema": "5.0.0-rc.10",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
     "c12": "^0.2.7",
@@ -56,10 +66,11 @@
     "unplugin": "^0.6.3",
     "untyped": "^0.4.4",
     "vite": "^2.9.9",
-    "vue": "^3"
+    "vue": "^3.2.33"
   },
   "devDependencies": {
-    "@types/fs-extra": "^9.0.13"
+    "@types/fs-extra": "^9.0.13",
+    "vue-router": "^4.0.15"
   },
   "engines": {
     "node": "^16.11.0 || ^17.0.0 || ^18.0.0"

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
-
-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() {
-  return {};
-}

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';