@monkeyplus/flow 5.0.0-rc.12 → 5.0.0-rc.121

package/dist/app/entry.async.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeConfig } from '@monkeyplus/flow-schema';
+declare const _default: (ctx?: RuntimeConfig) => Promise<any>;
+export default _default;

package/dist/app/entry.async.mjs

@@ -0,0 +1 @@
+export default (ctx) => import("#app/entry").then((m) => m.default(ctx));

package/dist/app/entry.mjs

@@ -17,7 +17,7 @@ export default async (runtimeConfig) => {
       });
     };
   } catch (err) {
-    console.log(err);
+    console.error(err);
   }
   return flow;
 };

package/dist/app/flow.d.ts

@@ -1,7 +1,7 @@
 import type { RadixRouter } from 'radix3';
 import type { Hookable } from 'hookable';
-import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
-declare type HookResult = Promise<void> | void;
+import type { FlowAppUtils, FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
+type HookResult = Promise<void> | void;
 export interface FlowAppHooks {
     'flow:pages': (page: FlowPage[]) => HookResult;
     'eta:plugin': (options: any) => 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,16 +31,20 @@ 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;
     provide: (name: string, value: any) => void;
     setUtil: (name: string, value: any) => void;
+    $config: RuntimeConfig;
     [key: string]: any;
 }
 export declare const FlowPluginIndicator = "__flow_plugin";

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/chunks/dev-bundler.mjs

@@ -0,0 +1,277 @@
+import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { resolve, normalize, isAbsolute } from 'pathe';
+import { genObjectFromRawEntries, genDynamicImport } from 'knitwork';
+import fse from 'fs-extra';
+import { debounce } from 'perfect-debounce';
+import { isIgnoredFlow, logger } from '@monkeyplus/flow-kit';
+import { hash } from 'ohash';
+import { ExternalsDefaults, isExternal } from 'externality';
+import { withTrailingSlash, withoutLeadingSlash } from 'ufo';
+import escapeRE from 'escape-string-regexp';
+import { normalizeViteManifest } from 'vue-bundle-renderer';
+
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+const IS_CSS_RE = /\.(?:css|scss|sass|postcss|less|stylus|styl)(\?[^.]+)?$/;
+function isCSS(file) {
+  return IS_CSS_RE.test(file);
+}
+function hashId(id) {
+  return `$id_${hash(id)}`;
+}
+
+function createIsExternal(viteServer, rootDir) {
+  const externalOpts = {
+    inline: [
+      /virtual:/,
+      /\.ts$/,
+      ...ExternalsDefaults.inline || [],
+      ...viteServer.config.ssr.noExternal
+    ],
+    external: [
+      ...viteServer.config.ssr.external || [],
+      /node_modules/
+    ],
+    resolve: {
+      type: "module",
+      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
+    }
+  };
+  return (id) => isExternal(id, rootDir, externalOpts);
+}
+
+async function writeManifest(ctx, css = []) {
+  const clientDist = resolve(ctx.nuxt.options.buildDir, "dist/client");
+  const serverDist = resolve(ctx.nuxt.options.buildDir, "dist/server");
+  const devClientManifest = {
+    "@vite/client": {
+      isEntry: true,
+      file: "@vite/client",
+      css,
+      module: true,
+      resourceType: "script"
+    },
+    [ctx.entry]: {
+      isEntry: true,
+      file: ctx.entry,
+      module: true,
+      resourceType: "script"
+    }
+  };
+  const clientManifest = ctx.nuxt.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
+  const buildAssetsDir = withTrailingSlash(withoutLeadingSlash(ctx.nuxt.options.app.buildAssetsDir));
+  const BASE_RE = new RegExp(`^${escapeRE(buildAssetsDir)}`);
+  for (const key in clientManifest) {
+    if (clientManifest[key].file)
+      clientManifest[key].file = clientManifest[key].file.replace(BASE_RE, "");
+    for (const item of ["css", "assets"]) {
+      if (clientManifest[key][item])
+        clientManifest[key][item] = clientManifest[key][item].map((i) => i.replace(BASE_RE, ""));
+    }
+  }
+  await fse.mkdirp(serverDist);
+  const manifest = normalizeViteManifest(clientManifest);
+  await ctx.nuxt.callHook("build:manifest", manifest);
+  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(manifest, null, 2)}`, "utf8");
+}
+
+async function transformRequest(opts, id) {
+  if (id && id.startsWith("/@id/__x00__"))
+    id = `\0${id.slice("/@id/__x00__".length)}`;
+  if (id && id.startsWith("/@id/"))
+    id = id.slice("/@id/".length);
+  if (id && !id.startsWith("/@fs/") && id.startsWith("/")) {
+    const resolvedPath = resolve(opts.viteServer.config.root, `.${id}`);
+    if (existsSync(resolvedPath))
+      id = resolvedPath;
+  }
+  id = id.replace(/^\/?(?=\w:)/, "/@fs/");
+  const externalId = id.replace(/\?v=\w+$|^\/@fs/, "");
+  if (await opts.isExternal(externalId)) {
+    const path = builtinModules.includes(externalId.split("node:").pop()) ? externalId : isAbsolute(externalId) ? pathToFileURL(externalId).href : externalId;
+    return {
+      code: `(global, module, _, exports, importMeta, ssrImport, ssrDynamicImport, ssrExportAll) =>
+${genDynamicImport(path, { wrapper: false })}
+  .then(r => {
+    if (r.default && r.default.__esModule)
+      r = r.default
+    exports.default = r.default
+    ssrExportAll(r)
+  })
+  .catch(e => {
+    console.error(e)
+    throw new Error(${JSON.stringify(`[vite dev] Error loading external "${id}".`)})
+  })`,
+      deps: [],
+      dynamicDeps: []
+    };
+  }
+  const res = await opts.viteServer.transformRequest(id, { ssr: true }).catch((err) => {
+    console.warn(`[SSR] Error transforming ${id}:`, err);
+  }) || { code: "", map: {}, deps: [], dynamicDeps: [] };
+  const code = `async function (global, module, exports, __vite_ssr_exports__, __vite_ssr_import_meta__, __vite_ssr_import__, __vite_ssr_dynamic_import__, __vite_ssr_exportAll__) {
+${res.code || "/* empty */"};
+}`;
+  return { code, deps: res.deps || [], dynamicDeps: res.dynamicDeps || [] };
+}
+async function transformRequestRecursive(opts, id, parent = "<entry>", chunks = {}) {
+  if (chunks[id]) {
+    chunks[id].parents.push(parent);
+    return;
+  }
+  const res = await transformRequest(opts, id);
+  const deps = uniq([...res.deps, ...res.dynamicDeps]);
+  chunks[id] = {
+    id,
+    code: res.code,
+    deps,
+    parents: [parent]
+  };
+  for (const dep of deps)
+    await transformRequestRecursive(opts, dep, id, chunks);
+  return Object.values(chunks);
+}
+async function bundleRequest(opts, entryURL) {
+  const chunks = await transformRequestRecursive(opts, entryURL);
+  const listIds = (ids) => ids.map((id) => `// - ${id} (${hashId(id)})`).join("\n");
+  const chunksCode = chunks.map((chunk) => `
+// --------------------
+// Request: ${chunk.id}
+// Parents: 
+${listIds(chunk.parents)}
+// Dependencies: 
+${listIds(chunk.deps)}
+// --------------------
+const ${hashId(`${chunk.id}-${chunk.code}`)} = ${chunk.code}
+`).join("\n");
+  const manifestCode = `const __modules__ = ${genObjectFromRawEntries(chunks.map((chunk) => [chunk.id, hashId(`${chunk.id}-${chunk.code}`)]))}`;
+  const ssrModuleLoader = `
+const __pendingModules__ = new Map()
+const __pendingImports__ = new Map()
+const __ssrContext__ = { global: globalThis }
+
+function __ssrLoadModule__(url, urlStack = []) {
+  const pendingModule = __pendingModules__.get(url)
+  if (pendingModule) { return pendingModule }
+  const modulePromise = __instantiateModule__(url, urlStack)
+  __pendingModules__.set(url, modulePromise)
+  modulePromise.catch(() => { __pendingModules__.delete(url) })
+         .finally(() => { __pendingModules__.delete(url) })
+  return modulePromise
+}
+
+async function __instantiateModule__(url, urlStack) {
+  const mod = __modules__[url]
+  if (mod.stubModule) { return mod.stubModule }
+  const stubModule = { [Symbol.toStringTag]: 'Module' }
+  Object.defineProperty(stubModule, '__esModule', { value: true })
+  mod.stubModule = stubModule
+  // https://vitejs.dev/guide/api-hmr.html
+  const importMeta = { url, hot: { accept() {}, prune() {}, dispose() {}, invalidate() {}, decline() {}, on() {} } }
+  urlStack = urlStack.concat(url)
+  const isCircular = url => urlStack.includes(url)
+  const pendingDeps = []
+  const ssrImport = async (dep) => {
+    // TODO: Handle externals if dep[0] !== '.' | '/'
+    if (!isCircular(dep) && !__pendingImports__.get(dep)?.some(isCircular)) {
+      pendingDeps.push(dep)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.set(url, pendingDeps)
+      }
+      await __ssrLoadModule__(dep, urlStack)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.delete(url)
+      } else {
+        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
+      }
+    }
+    return __modules__[dep].stubModule
+  }
+  function ssrDynamicImport (dep) {
+    // TODO: Handle dynamic import starting with . relative to url
+    return ssrImport(dep)
+  }
+
+  function ssrExportAll(sourceModule) {
+    for (const key in sourceModule) {
+      if (key !== 'default') {
+        try {
+          Object.defineProperty(stubModule, key, {
+            enumerable: true,
+            configurable: true,
+            get() { return sourceModule[key] }
+          })
+        } catch (_err) { }
+      }
+    }
+  }
+
+  const cjsModule = {
+    get exports () {
+      return stubModule.default
+    },
+    set exports (v) {
+      stubModule.default = v
+    },
+  }
+
+  await mod(
+    __ssrContext__.global,
+    cjsModule,
+    stubModule.default,
+    stubModule,
+    importMeta,
+    ssrImport,
+    ssrDynamicImport,
+    ssrExportAll
+  )
+
+  return stubModule
+}
+`;
+  const code = [
+    chunksCode,
+    manifestCode,
+    ssrModuleLoader,
+    `export default await __ssrLoadModule__(${JSON.stringify(entryURL)})`
+  ].join("\n\n");
+  return {
+    code,
+    ids: chunks.map((i) => i.id)
+  };
+}
+async function initViteDevBundler(ctx, onBuild) {
+  const viteServer = ctx.ssrServer;
+  const options = {
+    viteServer,
+    isExternal: createIsExternal(viteServer, ctx.nuxt.options.rootDir)
+  };
+  const _doBuild = async () => {
+    const start = Date.now();
+    const { code, ids } = await bundleRequest(options, ctx.entry);
+    await fse.ensureFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"));
+    await fse.writeFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"), code, "utf-8");
+    await writeManifest(ctx, ids.filter(isCSS).map((i) => i.slice(1)));
+    const time = Date.now() - start;
+    logger.success(`Vite server built in ${time}ms`);
+    ctx.nuxt.callHook("bundler:change", {});
+    await onBuild();
+  };
+  const doBuild = debounce(_doBuild);
+  await _doBuild();
+  viteServer.watcher.on("all", (_event, file) => {
+    if (file.includes("/pages/"))
+      return;
+    file = normalize(file);
+    if (file.indexOf(ctx.nuxt.options.buildDir) === 0 || isIgnoredFlow(file))
+      return;
+    doBuild();
+  });
+  ctx.nuxt.hook("app:templatesGenerated", () => doBuild());
+}
+
+export { bundleRequest, initViteDevBundler };

package/dist/core/runtime/client.manifest.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<any>;
+export default _default;

package/dist/core/runtime/client.manifest.mjs

@@ -0,0 +1,6 @@
+import { $fetch } from 'ohmyfetch';
+import { getViteNodeOptions } from './vite-node-shared.mjs';
+
+const viteNodeOptions = getViteNodeOptions();
+
+export default () => $fetch('/manifest', { baseURL: viteNodeOptions.baseURL });

package/dist/core/runtime/nitro/flow.d.ts

@@ -1,3 +1,4 @@
 import 'node-fetch-native/polyfill';
+export declare const getFlowRenderer: () => Promise<any>;
 declare const _default: import("h3").EventHandler<void>;
 export default _default;

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

@@ -1,25 +1,20 @@
-import { defineEventHandler } from "h3";
 import "node-fetch-native/polyfill";
-import { useRuntimeConfig } from "#internal/nitro";
-const getServerApp = cachedImport(() => import("#server"));
-const getFlowRenderer = cachedResult(async () => {
+import { eventHandler } from "h3";
+import { defineCachedFunction, useRuntimeConfig } from "#internal/nitro";
+const getServerApp = () => import("#server").then((r) => r?.default?.default || r?.default || r);
+export const getFlowRenderer = lazyCachedFunction(async () => {
   const createFlowApp = await getServerApp();
   if (!createFlowApp)
     throw new Error("Server bundle is not available");
   return createFlowApp(useRuntimeConfig());
 });
-export default defineEventHandler(async ({ context }) => {
+export default eventHandler(async (event) => {
   const flow = await getFlowRenderer();
-  context.flow = flow;
-  context.render = flow.render;
+  event.context.flow = flow;
+  event.context.render = flow.render;
+  event.context.defineCachedFunction = defineCachedFunction;
 });
-function _interopDefault(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
-}
-function cachedImport(importer) {
-  return cachedResult(() => importer().then(_interopDefault).then(_interopDefault));
-}
-function cachedResult(fn) {
+function lazyCachedFunction(fn) {
   let res = null;
   return () => {
     if (res === null)

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

@@ -1,46 +1,101 @@
-import { eventHandler, useQuery } from "h3";
+import { eventHandler, getQuery, readBody } from "h3";
+import { joinURL } from "ufo";
+import { getFlowRenderer } from "./flow.mjs";
+const normalizeCall = async (seo, ctx) => {
+  if (typeof seo === "function")
+    return await seo(ctx);
+  return seo || {};
+};
+function replacePath(_path, url) {
+  if (typeof url === "string") {
+    _path = joinURL(_path.replace("/**", ""), url);
+  } else {
+    Object.entries(url).forEach(([key, value]) => {
+      _path = _path.replace(`:${key}`, value);
+    });
+    if (url._ && _path.endsWith("**"))
+      _path = joinURL(_path.replace("/**", ""), url._);
+  }
+  return _path;
+}
 export default eventHandler(async (event) => {
   const url = event.req.url?.split("?")[0];
-  const flow = event.context.flow;
+  const flow = await getFlowRenderer();
   if (url.includes("_urls")) {
-    const urls = await flow.app.utils.getUrls();
+    const urls = await flow.app.utils.getUrls(false, true);
     return urls;
   }
   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, path: pagePath } = 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 isDynamic = !!Object.keys(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 = {
+    _post: {}
+  };
+  if (event.node.req.method.toLowerCase() === "post") {
+    const body = await readBody(event);
+    contextHooks._post = body;
+  }
+  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 (isDynamic && page.dynamic) {
     const pages = await page.dynamic.method({ locale, utils });
-    const dynamicPage = pages.find((_page) => _page.url === dynamyc);
+    const dynamicPage = pages.find((_page) => {
+      const aUrl = replacePath(pagePath, _page.url);
+      const bUrl = replacePath(pagePath, params);
+      return aUrl === bUrl;
+    });
     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
+  };
+  await flow.callHook("page:scripts", scripts, templateContext);
   templateContext.getHeadScripts = () => {
     return scripts.head.join("\n");
   };
+  templateContext.getBodyEndScripts = () => {
+    return scripts.bodyEnd.join("\n");
+  };
   templateContext.getHeadChunks = () => {
     return chunks.head.join("\n");
   };
@@ -50,10 +105,14 @@ export default eventHandler(async (event) => {
   templateContext.getInjectContext = () => {
     return `<script id="__FLOW_DATA__" type="application/json">${JSON.stringify(contextInject)}<\/script>`;
   };
-  const query = useQuery(event);
+  const query = getQuery(event);
   if (query?.context)
     return { ...templateContext, utils: Object.keys(utils) };
-  let html = await flow.render(view, templateContext);
+  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);

package/dist/core/runtime/vite-node-shared.d.mts

@@ -0,0 +1 @@
+export function getViteNodeOptions(): any;

package/dist/core/runtime/vite-node-shared.d.ts

@@ -0,0 +1,8 @@
+export interface ViteNodeRuntimeOptions {
+  baseURL: string
+  rootDir: string
+  entryPath: string
+  base: string
+}
+
+export function getViteNodeOptions (): ViteNodeRuntimeOptions;

package/dist/core/runtime/vite-node-shared.mjs

@@ -0,0 +1,3 @@
+export function getViteNodeOptions() {
+  return JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS || '{}');
+}

package/dist/core/runtime/vite-node.d.mts

@@ -0,0 +1,2 @@
+declare function _default(ssrContext: any): Promise<any>;
+export default _default;

package/dist/core/runtime/vite-node.mjs

@@ -0,0 +1,42 @@
+import { performance } from 'node:perf_hooks';
+import { ViteNodeRunner } from 'vite-node/client';
+import { $fetch } from 'ohmyfetch';
+import consola from 'consola';
+import { getViteNodeOptions } from './vite-node-shared.mjs';
+
+const viteNodeOptions = getViteNodeOptions();
+console.log(viteNodeOptions);
+const runner = new ViteNodeRunner({
+  root: viteNodeOptions.root, // Equals to Nuxt `srcDir`
+  base: viteNodeOptions.base,
+  async fetchModule(id) {
+    return await $fetch(`/module/${encodeURI(id)}`, {
+      baseURL: viteNodeOptions.baseURL,
+    });
+  },
+});
+
+let render;
+
+export default async(ssrContext) => {
+  // Workaround for stub mode
+  // https://github.com/nuxt/framework/pull/3983
+  process.server = true;
+
+  // Invalidate cache for files changed since last rendering
+  const invalidates = await $fetch('/invalidates', {
+    baseURL: viteNodeOptions.baseURL,
+  });
+  const updates = runner.moduleCache.invalidateDepTree(invalidates);
+
+  // Execute SSR bundle on demand
+  const start = performance.now();
+  render = render || (await runner.executeFile(viteNodeOptions.entryPath)).default;
+  if (updates.size) {
+    const time = Math.round((performance.now() - start) * 1000) / 1000;
+    consola.success(`Vite server hmr ${updates.size} files`, time ? `in ${time}ms` : '');
+  }
+
+  const result = await render(ssrContext);
+  return result;
+};

package/dist/head/runtime/plugin.mjs

@@ -1,6 +1,5 @@
 import { defineFlowPlugin } from "#app";
 export default defineFlowPlugin((flow) => {
   flow._useHead = (_meta) => {
-    console.log(_meta);
   };
 });