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

package/build.config.ts

@@ -0,0 +1,25 @@
+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/dist/app/entry.d.ts

@@ -1,3 +1,3 @@
 import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-export declare const entry: (runtimeConfig: RuntimeConfig) => Promise<import("./flow").FlowApp>;
-export default entry;
+declare const _default: (runtimeConfig: RuntimeConfig) => Promise<import("./flow").FlowApp>;
+export default _default;

package/dist/app/entry.mjs

@@ -1,7 +1,7 @@
 import { config, configure, render } from "eta";
 import { applyPlugins, createFlowApp } from "./flow.mjs";
 import plugins from "#build/plugins";
-export const entry = async (runtimeConfig) => {
+export default async (runtimeConfig) => {
   const flow = createFlowApp({ runtimeConfig });
   try {
     await applyPlugins(flow, plugins);
@@ -17,8 +17,7 @@ export const entry = async (runtimeConfig) => {
       });
     };
   } catch (err) {
-    console.error(err);
+    console.log(err);
   }
   return flow;
 };
-export default entry;

package/dist/app/flow.d.ts

@@ -1,7 +1,7 @@
 import type { RadixRouter } from 'radix3';
 import type { Hookable } from 'hookable';
-import type { FlowAppUtils, FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
-type HookResult = Promise<void> | void;
+import type { FlowPage, RuntimeConfig } from '@monkeyplus/flow-schema';
+declare type HookResult = Promise<void> | void;
 export interface FlowAppHooks {
     'flow:pages': (page: FlowPage[]) => HookResult;
     'eta:plugin': (options: any) => HookResult;
@@ -11,11 +11,6 @@ export interface FlowAppHooks {
         bodyStart: string[];
     }) => HookResult;
     'page:links': (links: string[]) => HookResult;
-    'page:context': (ctx: {
-        page: string;
-        localeCode: string;
-        ctx: any;
-    }, utils: any, data: Record<string, any>) => HookResult;
     'page:chunks': (bundle: string, scripts: {
         head: string[];
         body: string[];
@@ -32,20 +27,16 @@ 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;
     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,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.d.ts

@@ -1,4 +1,3 @@
 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,20 +1,25 @@
+import { defineEventHandler } from "h3";
 import "node-fetch-native/polyfill";
-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 () => {
+import { useRuntimeConfig } from "#internal/nitro";
+const getServerApp = cachedImport(() => import("#server"));
+const getFlowRenderer = cachedResult(async () => {
   const createFlowApp = await getServerApp();
   if (!createFlowApp)
     throw new Error("Server bundle is not available");
   return createFlowApp(useRuntimeConfig());
 });
-export default eventHandler(async (event) => {
+export default defineEventHandler(async ({ context }) => {
   const flow = await getFlowRenderer();
-  event.context.flow = flow;
-  event.context.render = flow.render;
-  event.context.defineCachedFunction = defineCachedFunction;
+  context.flow = flow;
+  context.render = flow.render;
 });
-function lazyCachedFunction(fn) {
+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) {
   let res = null;
   return () => {
     if (res === null)

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

@@ -1,120 +1,56 @@
-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;
-}
+import { eventHandler, useQuery } from "h3";
 export default eventHandler(async (event) => {
   const url = event.req.url?.split("?")[0];
-  const flow = await getFlowRenderer();
+  const flow = event.context.flow;
   if (url.includes("_urls")) {
-    const urls = await flow.app.utils.getUrls(false, true);
+    const urls = await flow.app.utils.getUrls();
     return urls;
   }
   const scripts = { head: [], bodyStart: [], bodyEnd: [] };
   const chunks = { head: [], body: [] };
   const generate = {};
-  const { page, locale, params, view, name: pageName, path: pagePath } = 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 isDynamic = !!Object.keys(params || {});
-  const contextPage = {
-    chunks,
-    locale,
-    _post: {}
-  };
-  const contextInject = {};
-  const utils = Object.assign({ getLocale: () => locale, injectContext: (key, value) => contextInject[key] = value, defineCachedFunction: event.context.defineCachedFunction }, flow.app.utils);
-  const contextHooks = {};
-  if (event.node.req.method.toLowerCase() === "post") {
-    const body = await readBody(event);
-    contextPage._post = body;
-  }
+  const dynamyc = params?._;
+  const contextPage = {};
+  const utils = Object.assign({ getLocale: () => locale }, 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 (isDynamic && page.dynamic) {
+  if (dynamyc && page.dynamic) {
     const pages = await page.dynamic.method({ locale, utils });
-    const dynamicPage = pages.find((_page) => {
-      const aUrl = replacePath(pagePath, _page.url);
-      const bUrl = replacePath(pagePath, params);
-      return aUrl === bUrl;
-    });
+    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;
   }
-  await flow.callHook("page:context", { localeCode: locale.code, page: pageName, ctx: contextPage }, utils, contextHooks);
   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");
   };
   templateContext.getBodyChunks = () => {
     return chunks.body.join("\n");
   };
-  templateContext.getInjectContext = () => {
-    return `<script id="__FLOW_DATA__" type="application/json">${JSON.stringify(contextInject)}<\/script>`;
-  };
-  const query = getQuery(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);
   };
 });