@monkeyplus/flow 5.0.0-rc.87 → 5.0.0-rc.9

package/dist/app/flow.d.ts

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

package/dist/head/runtime/plugin.mjs

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