@monkeyplus/flow 4.0.0-beta.8 → 5.0.0-beta.1

package/app.d.ts

@@ -0,0 +1 @@
+export * from './dist/app';

package/bin/flow.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '@monkeyplus/flow-cli/cli';

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/composables/index.d.ts

@@ -0,0 +1,4 @@
+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(): {};

package/dist/app/composables/index.mjs

@@ -0,0 +1,12 @@
+export function useCookie(name, _opts) {
+  return {};
+}
+export function refreshNuxtData(keys) {
+  return Promise.resolve();
+}
+export function useAsyncData(key, handlers) {
+  return handlers();
+}
+export function useRoute() {
+  return {};
+}

package/dist/app/entry.d.ts

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

package/dist/app/entry.mjs

@@ -0,0 +1,23 @@
+import { config, configure, render } from "eta";
+import { applyPlugins, createFlowApp } from "./flow.mjs";
+import plugins from "#build/plugins";
+export default async (runtimeConfig) => {
+  const flow = createFlowApp({ runtimeConfig });
+  try {
+    await applyPlugins(flow, plugins);
+    configure(flow.eta);
+    flow.render = (view, data) => {
+      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
+      });
+    };
+  } catch (err) {
+    console.log(err);
+  }
+  return flow;
+};

package/dist/app/flow.d.ts

@@ -0,0 +1,73 @@
+import type { RadixRouter } from 'radix3';
+import type { Hookable } from 'hookable';
+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;
+    '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 declare const FlowPluginIndicator = "__flow_plugin";
+export declare 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 declare function createFlowApp({ runtimeConfig }: OptionsApp): FlowApp;
+export declare function defineFlowPlugin<T>(plugin: Plugin<T>): Plugin<T>;
+export declare function defineNuxtPlugin<T>(plugin: Plugin<T>): Plugin<T>;
+export declare function applyPlugin(flowApp: FlowApp, plugin: Plugin): Promise<void>;
+export declare function applyPlugins(flowApp: FlowApp, plugins: Plugin[]): Promise<void>;
+/**
+ * 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 declare function callWithFlow<T extends (...args: any[]) => any>(flow: FlowApp, setup: T, args?: Parameters<T>): Promise<ReturnType<T>>;
+/**
+ * Returns the current Nuxt instance.
+ */
+export declare function useFlowApp(): FlowApp;
+export declare function useRuntimeConfig(): RuntimeConfig;
+export declare function resolveFiles(path: string, pattern: string | string[]): Promise<any[]>;
+export {};

package/dist/app/flow.mjs

@@ -0,0 +1,85 @@
+import { createRouter } from "radix3";
+import { createHooks } from "hookable";
+import { getContext } from "unctx";
+import { globby } from "globby";
+import { join, resolve } from "pathe";
+const flowAppCtx = getContext("flow-app");
+export const FlowPluginIndicator = "__flow_plugin";
+export const NuxtPluginIndicator = "__nuxt_plugin";
+export function createFlowApp({ runtimeConfig }) {
+  const viewsDir = join(runtimeConfig.app.rootDir, "views");
+  const flowApp = {
+    router: { byUrl: createRouter(), byName: createRouter() },
+    app: {
+      utils: {},
+      globals: {}
+    },
+    eta: {
+      views: viewsDir,
+      plugins: []
+    },
+    engine: "eta",
+    engines: {},
+    generate: runtimeConfig.generate
+  };
+  flowApp.engines.eta = (template) => {
+    return `<%~ await includeFile('templates/${template}',it) %>`;
+  };
+  flowApp.hooks = createHooks();
+  flowApp.hook = flowApp.hooks.hook;
+  flowApp.callHook = flowApp.hooks.callHook;
+  flowApp.provide = (name, value) => {
+    const $name = `$${name}`;
+    defineGetter(flowApp, $name, value);
+  };
+  flowApp.setUtil = (name, method) => {
+    flowApp.app.utils[name] = method;
+  };
+  flowApp.hook("eta:plugin", (_plugin) => {
+    flowApp.eta.plugins.push(_plugin);
+  });
+  flowApp.provide("config", runtimeConfig);
+  return flowApp;
+}
+export function defineFlowPlugin(plugin) {
+  plugin[FlowPluginIndicator] = true;
+  return plugin;
+}
+export function defineNuxtPlugin(plugin) {
+  plugin[NuxtPluginIndicator] = true;
+  return plugin;
+}
+export async function applyPlugin(flowApp, 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, plugins) {
+  for (const plugin of plugins)
+    await applyPlugin(flowApp, plugin);
+}
+export function callWithFlow(flow, setup, args) {
+  const fn = () => args ? setup(...args) : setup();
+  flowAppCtx.set(flow);
+  return flowAppCtx.callAsync(flow, fn);
+}
+export function useFlowApp() {
+  const flowAppInstance = flowAppCtx.use();
+  if (!flowAppInstance)
+    throw new Error("flow instance unavailable");
+  return flowAppInstance;
+}
+export function useRuntimeConfig() {
+  return useFlowApp().$config;
+}
+function defineGetter(obj, key, val) {
+  Object.defineProperty(obj, key, { get: () => val });
+}
+export async function resolveFiles(path, pattern) {
+  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
+  return files.filter((file) => !file.includes("copy.ts")).map((p) => resolve(path, p));
+}

package/dist/app/index.d.ts

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

package/dist/app/index.mjs

@@ -0,0 +1,3 @@
+export * from "./flow.mjs";
+export * from "./composables/index.mjs";
+export { useHead } from "#head";

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

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

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

@@ -0,0 +1,32 @@
+import { defineEventHandler } from "h3";
+import "node-fetch-native/polyfill";
+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 defineEventHandler(async ({ context }) => {
+  const flow = await getFlowRenderer();
+  context.flow = flow;
+  context.render = flow.render;
+});
+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)
+      res = fn().catch((err) => {
+        res = null;
+        throw err;
+      });
+    return res;
+  };
+}

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

@@ -0,0 +1,4 @@
+export declare function baseURL(): string;
+export declare function buildAssetsDir(): string;
+export declare function buildAssetsURL(...path: string[]): string;
+export declare function publicAssetsURL(...path: string[]): string;

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

@@ -0,0 +1,15 @@
+import { joinURL } from "ufo";
+import { useRuntimeConfig } from "#internal/nitro";
+export function baseURL() {
+  return useRuntimeConfig().app.baseURL;
+}
+export function buildAssetsDir() {
+  return useRuntimeConfig().app.buildAssetsDir;
+}
+export function buildAssetsURL(...path) {
+  return joinURL(publicAssetsURL(), useRuntimeConfig().app.buildAssetsDir, ...path);
+}
+export function publicAssetsURL(...path) {
+  const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
+  return path.length ? joinURL(publicBase, ...path) : publicBase;
+}

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<any>;
+export default _default;

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

@@ -0,0 +1,59 @@
+import { eventHandler, useQuery } from "h3";
+export default eventHandler(async (event) => {
+  const url = event.req.url?.split("?")[0];
+  const flow = event.context.flow;
+  if (url.includes("_urls")) {
+    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 } = flow.router.byUrl.lookup(url) || {};
+  await flow.callHook("page:scripts", scripts);
+  if (view.bundle)
+    await flow.callHook("page:chunks", view.bundle, chunks);
+  const templateContext = {};
+  if (!page)
+    return;
+  const dynamyc = params?._;
+  const contextPage = {};
+  const utils = Object.assign({ getLocale: () => locale }, flow.app.utils);
+  templateContext.url = url;
+  templateContext.locale = locale;
+  templateContext.view = view;
+  if (dynamyc && page.dynamic) {
+    const pages = await page.dynamic.method({ locale, utils });
+    const dynamicPage = pages.find((_page) => _page.url === dynamyc);
+    if (!dynamicPage)
+      return;
+    if (page.dynamic.assign)
+      templateContext[page.dynamic.assign] = dynamicPage.context;
+    contextPage.dynamyc = dynamicPage;
+  }
+  templateContext.seo = {};
+  templateContext.context = {};
+  templateContext.sharedContext = {};
+  templateContext.utils = utils;
+  templateContext.seo = await page.seo?.({ ...contextPage, utils }) || {};
+  templateContext.context = await page.context?.({ ...contextPage, utils }) || {};
+  templateContext.getHeadScripts = () => {
+    return scripts.head.join("\n");
+  };
+  templateContext.getHeadChunks = () => {
+    return chunks.head.join("\n");
+  };
+  templateContext.getBodyChunks = () => {
+    return chunks.body.join("\n");
+  };
+  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");
+  if (flow.generate) {
+    await flow.callHook("page:generate", generate);
+    globalThis.generate = generate;
+  }
+  return html;
+});

package/dist/head/runtime/composables.d.ts

@@ -0,0 +1,9 @@
+import type { MetaObject } from '@monkeyplus/flow-schema';
+/**
+ * You can pass in a meta object, which has keys corresponding to meta tags:
+ * `title`, `base`, `script`, `style`, `meta` and `link`, as well as `htmlAttrs` and `bodyAttrs`.
+ *
+ * Alternatively, for reactive meta state, you can pass in a function
+ * that returns a meta object.
+ */
+export declare function useHead(meta: MetaObject): void;

package/dist/head/runtime/composables.mjs

@@ -0,0 +1,2 @@
+export function useHead(meta) {
+}

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

@@ -0,0 +1 @@
+export * from './composables';

package/dist/head/runtime/index.mjs

@@ -0,0 +1 @@
+export * from "./composables.mjs";

package/dist/head/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/head/runtime/plugin.mjs

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

package/dist/index.d.ts

@@ -1,64 +1,11 @@
-import { Server, Plugin } from '@hapi/hapi';
-import { PageInfo } from '../types/core';
-import { OptionsHapiPage, RunPreDefinePage, Flow, FlowExtensions, OptionDynamicLocalePages, GenerateOptions, FlowServerMethods, FlowOptions } from '../types';
-export { ContextHandler, Contexts, Extension, Flow, FlowContextPage, FlowContextSeo, FlowContextView, FlowEngines, FlowExtensions, FlowOptionPlugins, FlowOptions, FlowPluginExtension, FlowPluginGlobal, FlowPluginLocal, FlowPluginUtils, FlowServerMethods, FlowStatePlugins, GenerateFolder, OptionDynamicLocalePages, OptionsDynamicPages, OptionsHapiPage, RunDefinePage, RunPreDefinePage } from '../types';
+import { FlowOptions, Flow, FlowConfig } from '@monkeyplus/flow-schema';
+export { FlowConfig } from '@monkeyplus/flow-schema';
+import { LoadFlowOptions } from '@monkeyplus/flow-kit';
 
-declare type DefinePage = (page: OptionsHapiPage) => RunPreDefinePage;
-declare const definePage: DefinePage;
+declare function createFlow(options: FlowOptions): Flow;
+declare function loadFlow(opts: LoadFlowOptions): Promise<Flow>;
+declare function defineFlowConfig(config: FlowConfig): FlowConfig;
 
-declare type HapiPages = OptionsHapiPage | OptionsHapiPage[];
-interface Context {
-    server: Server;
-}
-declare type Pages = (ctx: Context) => Promise<HapiPages>;
+declare function build(flow: Flow): Promise<void>;
 
-declare const plugin: Plugin<FlowOptions>;
-
-declare module '@hapi/hapi' {
-    interface ServerApplicationState {
-        flow: Flow.AppState;
-    }
-    interface RouteOptionsApp {
-        flow: PageInfo;
-    }
-    interface HandlerDecorations {
-        flow?: Flow.HandlerOptions;
-    }
-    interface PluginsStates {
-        flow: Flow.PluginState;
-    }
-    interface ResponseToolkit {
-        getUrl: (locale: string, name: string) => string;
-    }
-    interface PluginSpecificConfiguration {
-        flow?: {
-            proxy?: boolean;
-            extensions?: FlowExtensions;
-            dynamic?: OptionDynamicLocalePages;
-        };
-        generate?: GenerateOptions;
-    }
-    interface Server {
-        flow: Flow.Decorate;
-    }
-    interface ServerMethods {
-        flow: FlowServerMethods;
-    }
-    interface RequestApplicationState {
-        dynamic: any;
-    }
-    interface PluginProperties {
-        flow: {
-            configs: Flow.Configs;
-            helpers: {
-                getPath: (...paths: string[]) => string;
-                addRedirect: (key: string, urlPath: string) => void;
-                addStaticPage: (key: string, url: Flow.Page) => void;
-                addDynamicPages: (key: string, method: Flow.DynamicPages['']) => void;
-            };
-            pages: () => Flow.StaticPages;
-        };
-    }
-}
-
-export { Pages, definePage, plugin };
+export { build, createFlow, defineFlowConfig, loadFlow };