@monkeyplus/flow 4.0.0-beta.9 → 5.0.0-beta.10

package/dist/index.cjs

@@ -1,1061 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const path = require('path');
-const hoek = require('@hapi/hoek');
-const consola = require('consola');
-const R = require('ramda');
-const boom = require('@hapi/boom');
-const os = require('os');
-const chalk = require('chalk');
-const fs = require('fs-extra');
-const fs$1 = require('fs');
-const hookable = require('hookable');
-const chokidar = require('chokidar');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n["default"] = e;
-  return n;
-}
-
-const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
-const R__namespace = /*#__PURE__*/_interopNamespace(R);
-const os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
-const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-const fs__default$1 = /*#__PURE__*/_interopDefaultLegacy(fs$1);
-const chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
-
-const name = "@monkeyplus/flow";
-const version = "4.0.0-beta.9";
-const description = "Utils hapi";
-const author = "Andres Navarrete";
-const license = "MIT";
-const main = "./dist/index.cjs";
-const module$1 = "./dist/index.mjs";
-const types = "./dist/index.d.ts";
-const files = [
-	"dist/",
-	"types/"
-];
-const exports$1 = {
-	".": {
-		"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",
-	start: "esno src/index.ts",
-	test: "vitest"
-};
-const dependencies$1 = {
-	"@hapi/boom": "9.x.x",
-	"@hapi/hoek": "9.x.x",
-	consola: "^2.15.3",
-	chalk: "^4.1.2",
-	chokidar: "^3.5.3",
-	hookable: "^5.1.1",
-	"fs-extra": "^10.0.0",
-	ramda: "^0.28.0"
-};
-const devDependencies = {
-	"@types/fs-extra": "^9.0.13",
-	"@types/hapi__hapi": "^20.0.10",
-	"@types/hapi__nes": "^11.0.5",
-	"@types/hapi__vision": "^5.5.3",
-	"@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$1,
-	types: types,
-	files: files,
-	exports: exports$1,
-	scripts: scripts,
-	dependencies: dependencies$1,
-	devDependencies: devDependencies,
-	peerDependencies: peerDependencies,
-	gitHead: gitHead
-};
-
-const logger$1 = consola__default.withScope(pkg.name);
-const dependencies = {
-  "@hapi/vision": "6.x.x",
-  "@hapi/inert": "6.x.x",
-  "@hapi/h2o2": "9.x.x",
-  "@hapi/nes": "12.x.x"
-};
-const isProduction = process.env.NODE_ENV === "production";
-const isGenerate = process.env.GENERATE;
-
-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 boom.notFound();
-      Object.assign(req.plugins.flow.local, {
-        [dynamic.assign || "dynamic"]: page.context ?? { a: "" }
-      });
-      req.app.dynamic = R__namespace.omit(["context"], page);
-      return h.continue;
-    });
-  }
-};
-
-const ServerInfo = {
-  register: (server) => {
-    const serverInfo = () => {
-      const interfaces = os__default.networkInterfaces();
-      const hostname = "localhost";
-      const protocol = "http";
-      console.log("");
-      logger$1.success(chalk__default.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__default.bold(server.info.port)}`;
-        console.log(`  > ${type} ${chalk__default.cyan(url)}`);
-      }));
-    };
-    return { serverInfo };
-  }
-};
-
-function getLocalDefaults(loc, opts) {
-  const bundle = R__namespace.path(["locales", loc, "view", "bundle"], opts);
-  const view = R__namespace.path(["locales", loc, "view"], opts);
-  const runContext = R__namespace.path(["locales", loc, "context"], opts);
-  const seo = R__namespace.path(["locales", loc, "seo"], opts);
-  const blogInfo = R__namespace.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__default.posix.join("/", prefixLang, prefixUbication, levelBase, level);
-    const publicPath = defaultLocale.publicPath || "/";
-    const fullPath = path__default.posix.join("/", publicPath, prefixLevel, url);
-    const redirect = R__namespace.last(fullPath) === "/" ? path__default.posix.join(fullPath, "index.html") : void 0;
-    const app = {
-      localeName: path__default.posix.join(prefixName, locale, options.name),
-      name: options.name,
-      locale,
-      language,
-      level,
-      redirect,
-      seo: R__namespace.mergeDeepLeft(seo || {}, page.seo),
-      blogInfo: page.blogInfo,
-      urlObject: {
-        publicPath,
-        level: prefixLevel,
-        url,
-        path: fullPath,
-        static: R__namespace.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__namespace.clone({
-    ...R__namespace.pick(["publicPath", "path"], flow.urlObject),
-    ...R__namespace.pick([
-      "name",
-      "localeName",
-      "locale",
-      "level",
-      "template",
-      "bundle",
-      "language"
-    ], flow)
-  });
-  if (dynamic) {
-    Object.assign(page, {
-      path: dynamic.url,
-      ...R__namespace.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.layout || "default"}`, context);
-};
-
-const logger = consola__default.withScope("@monkeyplus/flow");
-const defaults = {
-  locales: ["es-ec"],
-  defaultUbication: "ec",
-  defaultLanguage: "es",
-  staticDir: "static",
-  hmr: {
-    dirs: ["views"]
-  },
-  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__default.resolve(options.relativeTo);
-  const getObject = (object) => {
-    const config = hoek.applyToDefaults(defaults, { ...object, ...options });
-    return {
-      ...config,
-      relativeTo,
-      locale: `${config.defaultLanguage}-${config.defaultUbication}`
-    };
-  };
-  try {
-    const pathWeb = path__default.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__default.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__default.ensureFile(file);
-      await fs__default.writeFile(file, payload, "utf8");
-    };
-    const useCreateFile = (isVirtual = false) => async (dir, url, ext) => {
-      if (typeof ext === "object") {
-        if (!isVirtual) {
-          const dirFile = path__default.dirname(url);
-          await fs__default.ensureDir(path__default.join(dir, dirFile));
-          const file = await fs__default.readFile(ext.file);
-          await fs__default.writeFile(path__default.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__default.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__namespace.last(url) === "/";
-              const nameFile = isIndex ? `${url}index.html` : `${url}.html`;
-              file = path__default.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__default.readdirSync(path__default.join(asset.relativeTo, dir));
-          for (const file of dirFiles) {
-            const pathFile = path__default.join(asset.relativeTo, dir, file);
-            const ext = path__default.extname(pathFile);
-            if (!!ext) {
-              const pathRoute = path__default.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__default.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__namespace.toPairs(files);
-      const ommit = ommitAssets;
-      try {
-        await fs__default.remove(dirOutut);
-        for (const dirStatic of staticDirs)
-          await fs__default.copy(dirStatic, dirOutut);
-        for (const omitFile of ommit)
-          await fs__default.remove(path__default.join(dirOutut, omitFile));
-        const createFile = useCreateFile(virtualGenerate);
-        const files2 = await Promise.all(pairFiles.map(async (v) => {
-          return await createFile(dirOutut, ...v);
-        }));
-        const groups = R__namespace.groupBy((file) => {
-          if (file.url.includes("images/"))
-            return "image";
-          else
-            return (path__default.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__default.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__namespace.mergeDeepRight(sharedOptions || {}, localOptions);
-      route.options = R__namespace.mergeDeepRight(options, route.options);
-      if (route.options && pre.length)
-        route.options.pre = pre;
-    }
-    return route;
-  });
-  return routes;
-};
-
-const readPagesDir = (pathDir, folder) => {
-  const p = fs__default$1.readdirSync(pathDir);
-  return R.flatten(p.filter((f) => !f.includes(".js.map") && !f.includes(" copy.js.map") && !f.includes(" copy.js") && !f.includes(".model")).map((e) => {
-    if (e.includes(".js") || e.includes(".ts")) {
-      return {
-        path: path__default.join(pathDir, e),
-        prefix: folder
-      };
-    } else {
-      return readPagesDir(path__default.join(pathDir, e), e);
-    }
-  }));
-};
-const registerPages = async (server, dir) => {
-  const dirPages = path__default.resolve(dir || "./pages");
-  const listFiles = readPagesDir(dirPages);
-  const listPrePages = [];
-  for (const item of listFiles) {
-    try {
-      const module = require(item.path)?.default;
-      if (typeof module === "function") {
-        listPrePages.push(module());
-      } else if (typeof module === "object") {
-        if (Array.isArray(module)) {
-          module.forEach((el) => listPrePages.push(el()));
-        } else {
-          const _pages = await module.pages({ server });
-          if (Array.isArray(_pages))
-            _pages.forEach((page) => listPrePages.push(definePage(page)()));
-          else
-            listPrePages.push(definePage(_pages)());
-        }
-      }
-    } catch (details) {
-      logger$1.error(details);
-    }
-  }
-  for (const page of listPrePages)
-    await server.flow.addPage(page);
-};
-
-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 registerPages2 = (_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);
-        registerPages2(_pages);
-      } else {
-        _pages = definePage(_page)()(config);
-        registerPages2(_pages);
-      }
-    };
-    const init = async () => {
-      await registerPages(server);
-      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 createHmr = (options) => {
-  const state = {
-    dir: options.relativeTo || "",
-    dirs: options.dirs || [],
-    extensions: options.extensions || ["eta"]
-  };
-  let watcher;
-  const hooks = hookable.createHooks();
-  const watch = () => {
-    watcher = chokidar__default.watch(state.dirs.map((d) => path__default.join(d, `**/*.(${state.extensions.join("|")})`)), {
-      cwd: state.dir,
-      ignoreInitial: true,
-      ignored: "node_modules/**/*"
-    }).on("change", (path2) => {
-      logger$1.info("Changed file", path2);
-      hooks.callHook("page:refresh");
-    });
-  };
-  watch();
-  return { watcher, hooks };
-};
-
-const RegisterCommon = async (server, configs) => {
-  server.route({
-    method: "GET",
-    path: "/{param*}",
-    options: {
-      ext: {
-        onPreResponse: {
-          method: (req, h) => {
-            return h.continue;
-          }
-        }
-      }
-    },
-    handler: {
-      directory: {
-        path: configs.staticDir,
-        listing: true
-      }
-    }
-  });
-  if (!isGenerate) {
-    const hmr = createHmr({
-      dirs: configs.hmr.dirs,
-      relativeTo: configs.relativeTo
-    });
-    hmr.hooks.hook("page:refresh", () => {
-      setTimeout(() => {
-        logger$1.info("Refresh page");
-        server.publish("/_flow/hmr", { reload: true });
-      }, 40);
-    });
-    server.subscription("/_flow/hmr");
-    server.route({
-      path: "/_flow/hmr/client.js",
-      method: "get",
-      handler: {
-        file: {
-          path: path.join(__dirname, "../resources/client"),
-          confine: false
-        }
-      }
-    });
-    server.route({
-      path: "/_flow/hmr/connect.js",
-      method: "get",
-      handler: {
-        file: {
-          path: path.join(__dirname, "../resources/ws.js"),
-          confine: false
-        }
-      }
-    });
-    logger$1.debug("Enable development routes");
-    server.route({
-      path: "/_flow/sitemap",
-      method: "get",
-      handler: async () => {
-        const { pages: getPages } = server.methods.flow;
-        const urls = await getPages();
-        const pages = Object.values(urls).map((p) => R.dissoc("context", p));
-        return {
-          total: pages.length,
-          pages
-        };
-      }
-    });
-    server.route({
-      path: "/_flow/locales",
-      method: "get",
-      handler: async (req) => {
-        const { pages: getPages } = server.methods.flow;
-        const urls = await getPages();
-        const pages = Object.values(urls).map((p) => R.dissoc("context", p));
-        const locales = R.groupBy((page) => page.locale, pages);
-        return {
-          locales: req.server.plugins.flow.configs.locales,
-          all: R.mapObjIndexed((l) => {
-            return {
-              total: l.length,
-              pages: l
-            };
-          }, locales)
-        };
-      }
-    });
-    server.route({
-      path: "/_flow/configs",
-      method: "get",
-      handler: (req) => {
-        return req.server.plugins.flow.configs;
-      }
-    });
-  }
-  const HMR = {
-    head: ' <script src="/_flow/hmr/client.js"><\/script>',
-    body: ' <script src="/_flow/hmr/connect.js"><\/script>'
-  };
-  server.ext("onPreHandler", async (req, h) => {
-    if (req.route.settings.plugins?.generate === ".html") {
-      const { global } = req.plugins.flow;
-      Object.assign(global, {
-        hmr: isProduction || isGenerate ? { head: "", body: "" } : HMR
-      });
-    }
-    return h.continue;
-  });
-};
-
-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__default.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 = hoek.applyToDefaults(d, options);
-      const { plugins } = config;
-      if (plugins[key] && Object.values(plugins[key])) {
-        if (typeof plugins[key] === "boolean") {
-          try {
-            const module = require(path__default.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 = hoek.applyToDefaults(baseOptions, opts2 || {});
-                  Object.assign(plugins, { [key]: _opts });
-                  return _opts;
-                });
-              }
-              Object.assign(plugins, { [key]: promise });
-              return promise;
-            }
-            const opts = hoek.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 = hoek.applyToDefaults(baseOptions, plugins[key]);
-          Object.assign(plugins, { [key]: opts });
-          return opts;
-        }
-      } else {
-        Object.assign(plugins, { [key]: baseOptions });
-        return baseOptions;
-      }
-    };
-    await RegisterCommon(server, config);
-  }
-};
-
-exports.definePage = definePage;
-exports.plugin = plugin;