@monkeyplus/flow 3.7.4 → 4.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,845 @@
+import path from 'path';
+import { applyToDefaults } from '@hapi/hoek';
+import consola from 'consola';
+import * as R from 'ramda';
+import { notFound } from '@hapi/boom';
+import os from 'os';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+
+const name = "@monkeyplus/flow";
+const version = "4.0.0-beta.1";
+const description = "Utils hapi";
+const author = "Andres Navarrete";
+const license = "MIT";
+const main = "./dist/index.cjs";
+const module = "./dist/index.mjs";
+const types = "./dist/index.d.ts";
+const files = [
+	"dist/",
+	"types/"
+];
+const exports = {
+	".": {
+		"import": "./dist/index.mjs",
+		require: "./dist/index.cjs"
+	}
+};
+const scripts = {
+	build: "unbuild",
+	dev: "pnpm stub && pnpm types",
+	stub: "unbuild --stub",
+	types: "tsup ./src/index.ts --dts-only --external types && esno ../../scripts/replace",
+	lint: "eslint --ext .js,.ts .",
+	fix: "eslint --fix --ext .ts .",
+	prepublishOnly: "pnpm run build",
+	publish: "pnpm publish",
+	start: "esno src/index.ts",
+	test: "vitest"
+};
+const dependencies$1 = {
+	"@hapi/boom": "9.x.x",
+	"@hapi/hoek": "9.x.x",
+	chalk: "^5.0.0",
+	consola: "^2.15.3",
+	"fs-extra": "^10.0.0",
+	ramda: "^0.28.0"
+};
+const devDependencies = {
+	"@types/fs-extra": "^9.0.13",
+	"@types/hapi__hapi": "^20.0.10",
+	"@types/ramda": "^0.27.64"
+};
+const peerDependencies = {
+	"@hapi/hapi": "^20.x"
+};
+const gitHead = "1d5387b9c77909019f36d360a0ac53ddaa40e4af";
+const pkg = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	license: license,
+	main: main,
+	module: module,
+	types: types,
+	files: files,
+	exports: exports,
+	scripts: scripts,
+	dependencies: dependencies$1,
+	devDependencies: devDependencies,
+	peerDependencies: peerDependencies,
+	gitHead: gitHead
+};
+
+const logger$1 = consola.withScope(pkg.name);
+const dependencies = {
+  "@hapi/vision": "6.x.x"
+};
+
+const LifeCircle = {
+  register: (server) => {
+    server.ext("onPreStart", async () => {
+      await server.methods.flow.pages();
+    });
+    server.ext("onRequest", async (req, h) => {
+      await server.methods.flow.pages();
+      const stateRequest = {
+        global: {},
+        local: {},
+        context: {},
+        utils: {},
+        extensions: {}
+      };
+      req.plugins.flow = stateRequest;
+      const { flow: state } = server.app;
+      const pathRedirect = state.pages.redirects[req.path];
+      if (state.truncates[req.path])
+        return h.redirect("/").takeover();
+      if (pathRedirect)
+        return h.redirect(pathRedirect).takeover();
+      return h.continue;
+    });
+    server.ext("onPreHandler", async (req, h) => {
+      const { dynamic } = req.route.settings.plugins?.flow || {};
+      const flow = req.route.settings.app?.flow;
+      if (!dynamic)
+        return h.continue;
+      const pages = await dynamic.pages({
+        server,
+        route: req.route,
+        locale: flow?.locale
+      });
+      if (!pages || !pages.length)
+        return h.continue;
+      const page = pages.find((_page) => _page.url === req.params.url);
+      if (!page)
+        return notFound();
+      Object.assign(req.plugins.flow.local, {
+        [dynamic.assign || "dynamic"]: page.context ?? { a: "" }
+      });
+      req.app.dynamic = R.omit(["context"], page);
+      return h.continue;
+    });
+  }
+};
+
+const ServerInfo = {
+  register: (server) => {
+    const serverInfo = () => {
+      const interfaces = os.networkInterfaces();
+      const hostname = "localhost";
+      const protocol = "http";
+      console.log("");
+      logger$1.success(chalk.green(`Flow v${pkg.version} dev server running at:`));
+      console.log("");
+      Object.keys(interfaces).forEach((key) => (interfaces[key] || []).filter((details) => details.family === "IPv4").map((detail) => {
+        return {
+          type: detail.address.includes("127.0.0.1") ? "Local:   " : "Network: ",
+          host: detail.address.replace("127.0.0.1", hostname)
+        };
+      }).forEach(({ type, host }) => {
+        const url = `${protocol}://${host}:${chalk.bold(server.info.port)}`;
+        console.log(`  > ${type} ${chalk.cyan(url)}`);
+      }));
+    };
+    return { serverInfo };
+  }
+};
+
+function getLocalDefaults(loc, opts) {
+  const bundle = R.path(["locales", loc, "view", "bundle"], opts);
+  const view = R.path(["locales", loc, "view"], opts);
+  const runContext = R.path(["locales", loc, "context"], opts);
+  const seo = R.path(["locales", loc, "seo"], opts);
+  const blogInfo = R.path(["locales", loc, "blogInfo"], opts);
+  return {
+    bundle,
+    view,
+    runContext,
+    seo: seo || {},
+    blogInfo
+  };
+}
+function getLevel(locale, defLevel) {
+  const level = typeof defLevel === "string" ? defLevel : typeof defLevel === "object" ? defLevel.locales[locale] || defLevel.default : "";
+  return level;
+}
+const definePages = (options) => (defaultLocale) => (levelOptions = {}) => {
+  const prefixName = levelOptions.prefixName || "";
+  const pages = (locales) => locales.map(({ locale, url, seo }) => {
+    const page = getLocalDefaults(locale, options);
+    const levelBase = getLevel(locale, levelOptions.level);
+    const level = getLevel(locale, options.level);
+    const [language, ubication] = locale.split("-");
+    const prefixLang = language === defaultLocale.language ? "" : language;
+    const prefixUbication = ubication === defaultLocale.ubication ? "" : ubication;
+    const prefixLevel = path.posix.join("/", prefixLang, prefixUbication, levelBase, level);
+    const publicPath = defaultLocale.publicPath || "/";
+    const fullPath = path.posix.join("/", publicPath, prefixLevel, url);
+    const redirect = R.last(fullPath) === "/" ? path.posix.join(fullPath, "index.html") : void 0;
+    const app = {
+      localeName: path.posix.join(prefixName, locale, options.name),
+      name: options.name,
+      locale,
+      language,
+      level,
+      redirect,
+      seo: R.mergeDeepLeft(seo || {}, page.seo),
+      blogInfo: page.blogInfo,
+      urlObject: {
+        publicPath,
+        level: prefixLevel,
+        url,
+        path: fullPath,
+        static: R.last(fullPath) === "/" ? `${fullPath}index.html` : `${fullPath}.html`
+      },
+      view: { ...options.view, ...page.view },
+      runSharedContext: options.context,
+      runLocalContext: page.runContext
+    };
+    return app;
+  });
+  return {
+    name: options.name,
+    pages
+  };
+};
+
+const handlerPage = async (req, h) => {
+  const { configs } = req.server.plugins.flow;
+  const { flow } = req.route.settings.app;
+  const { dynamic } = req.app;
+  const local = {};
+  const global = {};
+  const page = R.clone({
+    ...R.pick(["publicPath", "path"], flow.urlObject),
+    ...R.pick([
+      "name",
+      "localeName",
+      "locale",
+      "level",
+      "template",
+      "bundle",
+      "language"
+    ], flow)
+  });
+  if (dynamic) {
+    Object.assign(page, {
+      path: dynamic.url,
+      ...R.omit(["url"], dynamic)
+    });
+  }
+  const utils = {
+    ...req.plugins.flow.utils,
+    getLocalUrl: (name) => {
+      return h.getUrl(flow.locale, name);
+    },
+    getUrl: h.getUrl
+  };
+  const seo = {
+    ...flow.seo,
+    ...req.pre.seo,
+    url: configs.url,
+    pageUrl: `${configs.url}${req.url.pathname}`
+  };
+  const contextMethod = {
+    seo,
+    req,
+    h,
+    page,
+    extensions: req.plugins.flow.extensions,
+    global: req.plugins.flow.global,
+    utils
+  };
+  const extraContexts = req.plugins.flow.context;
+  for (const key in extraContexts) {
+    if (extraContexts[key]?.method) {
+      const assign = extraContexts[key].assign;
+      const data = await extraContexts[key].method(contextMethod);
+      const _context = { [key]: data };
+      if (assign === "global")
+        Object.assign(global, _context);
+      else if (assign === "local")
+        Object.assign(local, _context);
+      else
+        Object.assign(seo, _context);
+    }
+  }
+  if (flow.runSharedContext) {
+    const _context = await flow.runSharedContext(contextMethod);
+    Object.assign(local, _context);
+  }
+  if (flow.runLocalContext) {
+    const _context = await flow.runLocalContext(contextMethod);
+    Object.assign(local, _context);
+  }
+  const context = {
+    view: flow.view,
+    context: Object.freeze({ ...local, ...req.plugins.flow.local }),
+    seo,
+    page,
+    utils: {},
+    hapi: { req, h },
+    global: Object.freeze({ ...global, ...req.plugins.flow.global })
+  };
+  if (req.query.context) {
+    context.utils = Object.keys(utils);
+    context.hapi = ["req", "h"];
+    return context;
+  }
+  context.utils = utils;
+  return h.view(`${configs.dirTemplates}${flow.view.template}`, context);
+};
+
+const logger = consola.withScope("@monkeyplus/flow");
+const defaults = {
+  locales: ["es-ec"],
+  defaultUbication: "ec",
+  defaultLanguage: "es",
+  publicPath: "/",
+  locale: "es-ec",
+  relativeTo: "",
+  dirTemplates: "",
+  outputDir: "build",
+  url: process.env.CUSTOM_URL || process.env.URL,
+  engines: ["eta"],
+  plugins: {}
+};
+function getConfigs(server, options) {
+  const relativeTo = path.resolve(options.relativeTo);
+  const getObject = (object) => {
+    const config = applyToDefaults(defaults, { ...object, ...options });
+    return {
+      ...config,
+      relativeTo,
+      locale: `${config.defaultLanguage}-${config.defaultUbication}`
+    };
+  };
+  try {
+    const pathWeb = path.resolve(options.relativeTo, "flow.config");
+    logger.info("Flow apply settings from file: flow.config");
+    const configBase = require(pathWeb);
+    const config = getObject(configBase);
+    return config;
+  } catch (error) {
+    logger.info("Flow no config file apply default settings");
+    return getObject({});
+  }
+}
+const isDinamyc = (url) => /\{url?(.+)\}/.test(url);
+
+const Decorators = {
+  register: (server) => {
+    const { flow: state } = server.app;
+    const { configs, helpers } = server.plugins.flow;
+    const flowDecorate = (route, options) => {
+      const { plugins, app } = route.settings;
+      Object.assign(plugins, { generate: ".html" });
+      const flow = app.flow;
+      const runCommons = (pageInfo) => {
+        helpers.addStaticPage(pageInfo.localeName, {
+          url: route.path,
+          locale: pageInfo.locale,
+          localeName: pageInfo.localeName,
+          name: pageInfo.name
+        });
+        if (pageInfo.redirect)
+          helpers.addRedirect(pageInfo.redirect, route.path);
+      };
+      if (flow) {
+        runCommons(flow);
+      } else {
+        const routes = definePages({
+          name: options.name,
+          view: options.view,
+          locales: {
+            [options.locale || configs.locale]: {}
+          },
+          context: options.context
+        })({
+          language: configs.defaultLanguage,
+          ubication: configs.defaultUbication,
+          publicPath: configs.publicPath
+        })().pages([
+          { locale: options.locale || configs.locale, url: route.path }
+        ]);
+        const pageInfo = routes[0];
+        runCommons(pageInfo);
+        Object.assign(app, { flow: pageInfo, content: options.content });
+      }
+      const extensions = plugins?.flow?.extensions || {};
+      if (isDinamyc(route.path)) {
+        if (!route.settings.plugins?.flow?.dynamic)
+          throw new Error("Dynamic pages require a method");
+        helpers.addDynamicPages(flow.localeName, ((options2) => async () => {
+          const _pages = await route.settings.plugins?.flow?.dynamic?.pages(options2);
+          const obj = {};
+          for (const sPage of _pages || []) {
+            const localeName = `${app?.flow.localeName}/${sPage.name}`;
+            obj[localeName] = {
+              locale: app?.flow.locale,
+              localeName,
+              name: localeName.replace(`${app?.flow.locale}/`, ""),
+              url: route.path.replace("{url*}", sPage.url),
+              context: sPage.context,
+              dynamicSlug: sPage.dynamicSlug
+            };
+          }
+          return obj;
+        })({
+          server,
+          route,
+          locale: app?.flow.locale
+        }));
+      }
+      for (const extension in extensions) {
+        const optionExtension = plugins?.flow?.extensions[extension];
+        const routeMethod = state.extensions[extension]?.routeMethod;
+        if (routeMethod)
+          routeMethod({ pageInfo: app.flow, route }, optionExtension);
+      }
+      return handlerPage;
+    };
+    const getUrl = (_locale, _name) => {
+      try {
+        const pageName = path.posix.join(_locale, _name);
+        const page = state.pages.all[pageName];
+        if (page) {
+          return page.url;
+        } else {
+          logger$1.warn("Not found link with name: %s", pageName);
+          return "/404";
+        }
+      } catch (error) {
+        logger$1.error(error);
+        return "/";
+      }
+    };
+    server.method("flow.getUrl", getUrl, {});
+    server.decorate("handler", "flow", flowDecorate);
+    server.decorate("toolkit", "getUrl", server.methods.flow.getUrl);
+  }
+};
+
+const useGenerator = {
+  register: (server) => {
+    const { configs, helpers } = server.plugins.flow;
+    const getFlowPages = async () => {
+      const files = {};
+      const allPages = await server.methods.flow.pages();
+      const pages = Object.values(allPages);
+      logger.success("Read %i static pages", pages.length);
+      for (const page of pages)
+        files[page.url] = ".html";
+      const routes = server.table();
+      for (const route of routes) {
+        const isDynamic = /\{url?(.+)\}/.test(route.path);
+        const generate = route.settings.plugins?.generate;
+        if (!isDynamic && generate) {
+          if (!files[route.path])
+            files[route.path] = generate;
+        }
+      }
+      return files;
+    };
+    const writeFile = async (file, payload) => {
+      await fs.ensureFile(file);
+      await fs.writeFile(file, payload, "utf8");
+    };
+    const useCreateFile = (isVirtual = false) => async (dir, url, ext) => {
+      if (typeof ext === "object") {
+        if (!isVirtual) {
+          const dirFile = path.dirname(url);
+          await fs.ensureDir(path.join(dir, dirFile));
+          const file = await fs.readFile(ext.file);
+          await fs.writeFile(path.join(dir, url), file);
+        }
+        return { type: ext.type || "assets", url };
+      } else {
+        const r = await server.inject({
+          url,
+          method: "get"
+        });
+        let file = "";
+        if (typeof ext === "boolean") {
+          if (!isVirtual) {
+            file = path.join(dir, url);
+            await writeFile(file, r.payload);
+          }
+          return { type: "assets", url };
+        } else if (typeof ext === "string") {
+          if (ext === ".html") {
+            if (!isVirtual) {
+              const isIndex = R.last(url) === "/";
+              const nameFile = isIndex ? `${url}index.html` : `${url}.html`;
+              file = path.join(dir, nameFile);
+              await writeFile(file, r.payload);
+            }
+            return { type: "page", url };
+          }
+        }
+        return { type: "asset", url };
+      }
+    };
+    const injectAssets = (assets) => {
+      for (const asset of assets) {
+        const dirs = asset.dirs;
+        for (const dir of dirs) {
+          const dirFiles = fs.readdirSync(path.join(asset.relativeTo, dir));
+          for (const file of dirFiles) {
+            const pathFile = path.join(asset.relativeTo, dir, file);
+            const ext = path.extname(pathFile);
+            if (!!ext) {
+              const pathRoute = path.posix.join("/", asset.prefix, dir, file);
+              const pathRouteOverride = asset.override?.[pathRoute];
+              server.route({
+                path: pathRouteOverride || pathRoute,
+                method: "get",
+                options: {
+                  plugins: {
+                    generate: {
+                      isAsset: true,
+                      file: pathFile,
+                      type: asset.type,
+                      isRemane: !!pathRouteOverride
+                    }
+                  }
+                },
+                handler: {
+                  file: {
+                    path: pathFile,
+                    confine: false
+                  }
+                }
+              });
+            } else {
+              injectAssets([
+                {
+                  dirs: [path.posix.join(dir, file)],
+                  prefix: asset.prefix,
+                  relativeTo: asset.relativeTo,
+                  override: asset.override,
+                  type: asset.type || file
+                }
+              ]);
+            }
+          }
+        }
+      }
+    };
+    const runGenerate = async ({
+      assets = [],
+      ommitAssets = [],
+      virtualGenerate = false
+    }) => {
+      await server.methods.flow.pages();
+      const _assetsApp = [...Object.values(server.app.flow.generate.folders)];
+      const _assets = [...assets, ..._assetsApp];
+      if (!virtualGenerate)
+        injectAssets(_assets);
+      const dirOutut = helpers.getPath(configs.outputDir ?? "build");
+      const staticDirs = Object.keys(server.app.flow.generate.staticFolders).map((dir) => helpers.getPath(dir));
+      const files = await getFlowPages();
+      const pairFiles = R.toPairs(files);
+      const ommit = ommitAssets;
+      try {
+        await fs.remove(dirOutut);
+        for (const dirStatic of staticDirs)
+          await fs.copy(dirStatic, dirOutut);
+        for (const omitFile of ommit)
+          await fs.remove(path.join(dirOutut, omitFile));
+        const createFile = useCreateFile(virtualGenerate);
+        const files2 = await Promise.all(pairFiles.map(async (v) => {
+          return await createFile(dirOutut, ...v);
+        }));
+        const groups = R.groupBy((file) => {
+          if (file.url.includes("images/"))
+            return "image";
+          else
+            return (path.extname(file.url) || file.type).toLowerCase();
+        }, files2);
+        const _groups = {
+          pages: 0,
+          js: 0,
+          css: 0,
+          images: 0,
+          fonts: 0,
+          others: 0
+        };
+        for (const type in groups) {
+          const cp = (ext) => ext === type;
+          const qty = groups[type].length;
+          if (type === "page")
+            _groups.pages += qty;
+          else if (type === ".js")
+            _groups.js += qty;
+          else if (type === ".css")
+            _groups.css += qty;
+          else if ([".gif", ".png", ".jpg", ".jpeg", "image"].find(cp))
+            _groups.images += qty;
+          else if ([".woff", ".eot", ".ttf"].find(cp))
+            _groups.fonts += qty;
+          else
+            _groups.others += qty;
+        }
+        for (const type in _groups)
+          logger.success("%i %s generated", _groups[type], type);
+        const bf = server.app.flow.generate.postGenerate;
+        if (Object.keys(bf).length) {
+          logger.info("Post generate");
+        }
+        for (const key in bf)
+          await bf[key]();
+      } catch (error) {
+        logger.error(error);
+        await fs.remove(dirOutut);
+        throw new Error(error);
+      }
+    };
+    return { runGenerate };
+  }
+};
+
+const definePage = (pageOptions) => (levelOptions) => (configs) => {
+  const pages = [];
+  for (const locale in pageOptions.locales) {
+    if (configs.locales.find((_locale) => _locale === locale)) {
+      const singlePage = pageOptions.locales[locale];
+      pages.push({ url: singlePage.url, locale });
+    }
+  }
+  const infoPages = definePages({
+    name: pageOptions.name,
+    view: pageOptions.view,
+    context: pageOptions.context,
+    level: pageOptions.level,
+    locales: pageOptions.locales
+  })({
+    language: configs.defaultLanguage,
+    ubication: configs.defaultUbication,
+    publicPath: configs.publicPath
+  })(levelOptions).pages(pages);
+  const {
+    options: sharedOptions,
+    rules: sharedRules,
+    vhost: sharedVHost
+  } = pageOptions;
+  const sharedPre = sharedOptions?.pre || [];
+  const routes = infoPages.map((page) => {
+    const localPage = pageOptions.locales[page.locale];
+    const route = {
+      path: page.urlObject.path,
+      method: "get",
+      options: {
+        app: {
+          flow: page
+        },
+        plugins: {
+          flow: {
+            extensions: pageOptions.extensions || {},
+            dynamic: localPage.dynamic
+          }
+        }
+      },
+      handler: {
+        flow: {
+          name: page.localeName,
+          locale: page.locale,
+          view: page.view
+        }
+      }
+    };
+    if (sharedRules || localPage.rules)
+      route.rules = localPage.rules || sharedRules;
+    if (sharedVHost || localPage.vhost)
+      route.vhost = localPage.vhost || sharedVHost;
+    if (sharedOptions || localPage.options) {
+      const localOptions = localPage?.options || {};
+      const localPre = localPage?.options?.pre || [];
+      const pre = [...sharedPre, ...localPre];
+      const options = R.mergeDeepRight(sharedOptions || {}, localOptions);
+      route.options = R.mergeDeepRight(options, route.options);
+      if (route.options && pre.length)
+        route.options.pre = pre;
+    }
+    return route;
+  });
+  return routes;
+};
+
+const RunMethods = {
+  register: (server) => {
+    const { flow: state } = server.app;
+    const { configs: config } = server.plugins.flow;
+    const registerRoute = (route) => {
+      const _routes = server.table();
+      const _route = _routes.find((v) => v.path === route.path);
+      if (_route)
+        logger$1.warn(`Duplicate route, the route ${route.path} already exists`);
+      else
+        server.route(route);
+    };
+    const addPage = (_page, extra) => {
+      const registerPages = (_pages2) => {
+        for (const _route of _pages2) {
+          if (state.routes[_route.path])
+            logger$1.warn("The route %s alredy exist", _route.path);
+          else
+            state.routes[_route.path] = _route;
+        }
+      };
+      let _pages;
+      if (typeof _page === "function") {
+        _pages = _page(config);
+        registerPages(_pages);
+      } else {
+        _pages = definePage(_page)()(config);
+        registerPages(_pages);
+      }
+    };
+    const init = async () => {
+      const pages = server.app.flow.routes;
+      for (const key in pages) {
+        const page = pages[key];
+        registerRoute(page);
+      }
+      for (const key in state.extensions) {
+        const ext = state.extensions[key];
+        if (ext.initMethod)
+          await ext.initMethod();
+      }
+      logger$1.debug("Register %s pages", `${Object.values(pages).length}`);
+    };
+    return { init, addPage };
+  }
+};
+
+const plugin = {
+  pkg,
+  dependencies,
+  register: async (server, _options) => {
+    const config = getConfigs(server, _options);
+    server.expose("configs", config);
+    const state = {
+      pages: { statics: {}, redirects: {}, dynamics: {}, all: {} },
+      truncates: {},
+      extensions: {},
+      generate: {
+        folders: {},
+        staticFolders: {},
+        postGenerate: {},
+        beforePackage: {}
+      },
+      engines: {},
+      routes: {},
+      plugins: {}
+    };
+    server.app.flow = state;
+    const { serverInfo } = ServerInfo.register(server);
+    const serverDecorate = {
+      serverInfo
+    };
+    const helpers = {
+      getPath: (...paths) => path.join(config.relativeTo, ...paths),
+      addRedirect: (key, urlPath) => {
+        state.pages.redirects[key] = urlPath;
+      },
+      addStaticPage: (key, url) => {
+        if (isDinamyc(url.url))
+          return void 0;
+        if (state.pages.statics[key]) {
+          logger$1.warn("The namePage %s already exist", state.pages.statics[key]);
+        } else {
+          state.pages.statics[key] = url;
+        }
+      },
+      addDynamicPages: (key, method) => {
+        if (state.pages.dynamics[key])
+          logger$1.warn("The dynamdcPages %s already exist", key);
+        else
+          state.pages.dynamics[key] = method;
+      }
+    };
+    server.expose("helpers", helpers);
+    server.method("flow.pages", async () => {
+      const pages = {
+        ...state.pages.statics
+      };
+      for (const key in state.pages.dynamics) {
+        if (Object.prototype.hasOwnProperty.call(state.pages.dynamics, key)) {
+          const element = state.pages.dynamics[key];
+          const dynamicPages = await element();
+          for (const keyPage in dynamicPages) {
+            if (Object.prototype.hasOwnProperty.call(dynamicPages, keyPage)) {
+              const page = dynamicPages[keyPage];
+              if (!pages[keyPage])
+                pages[keyPage] = page;
+              else
+                logger$1.warn("Duplicate page %s", keyPage);
+            }
+          }
+        }
+      }
+      state.pages.all = pages;
+      return pages;
+    }, {
+      cache: { expiresIn: 3e3, generateTimeout: 8e3 }
+    });
+    server.expose("pages", () => {
+      return state.pages.all;
+    });
+    server.decorate("server", "flow", serverDecorate);
+    Decorators.register(server);
+    LifeCircle.register(server);
+    const { runGenerate } = useGenerator.register(server);
+    serverDecorate.runGenerate = runGenerate;
+    const { addPage, init } = RunMethods.register(server);
+    serverDecorate.addPage = addPage;
+    serverDecorate.init = init;
+    serverDecorate.prepagePackage = async () => {
+      for (const key in state.generate.beforePackage)
+        await state.generate.beforePackage[key]();
+    };
+    serverDecorate.assignPluginOptions = (realm, options = {}, d = {}, _context) => {
+      const key = realm.plugin.replace("@monkeyplus/", "").replace("flow-", "");
+      const baseOptions = applyToDefaults(d, options);
+      const { plugins } = config;
+      if (plugins[key] && Object.values(plugins[key])) {
+        if (typeof plugins[key] === "boolean") {
+          try {
+            const module = require(path.resolve("./extensions", key))?.default;
+            if (typeof module === "function") {
+              const promise = module({ server, ..._context });
+              const isPromise = !!promise && typeof promise.then === "function";
+              if (isPromise) {
+                return promise.then((opts2) => {
+                  const _opts = applyToDefaults(baseOptions, opts2 || {});
+                  Object.assign(plugins, { [key]: _opts });
+                  return _opts;
+                });
+              }
+              Object.assign(plugins, { [key]: promise });
+              return promise;
+            }
+            const opts = applyToDefaults(baseOptions, module || {});
+            Object.assign(plugins, { [key]: opts });
+            return opts;
+          } catch (error) {
+            logger$1.error("Error in load extension: %s", key);
+            return baseOptions;
+          }
+        } else {
+          const opts = applyToDefaults(baseOptions, plugins[key]);
+          Object.assign(plugins, { [key]: opts });
+          return opts;
+        }
+      } else {
+        Object.assign(plugins, { [key]: baseOptions });
+        return baseOptions;
+      }
+    };
+  }
+};
+
+export { definePage, plugin };