@modern-js/server-core 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/plugins/render/render.js

@@ -1,253 +0,0 @@
-import { cutNameByHyphen } from "@modern-js/utils/universal";
-import { TrieRouter } from "hono/router/trie-router";
-import { X_MODERNJS_RENDER } from "../../constants";
-import { uniqueKeyByRoute } from "../../utils";
-import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, parseHeaders, parseQuery, sortRoutes } from "../../utils";
-import { csrRscRender } from "./csrRscRender";
-import { dataHandler } from "./dataHandler";
-import { renderRscHandler } from "./renderRscHandler";
-import { serverActionHandler } from "./serverActionHandler";
-import { ssrRender } from "./ssrRender";
-const DYNAMIC_ROUTE_REG = /\/:./;
-function getRouter(routes) {
-  const dynamicRoutes = [];
-  const normalRoutes = [];
-  routes.forEach((route) => {
-    if (DYNAMIC_ROUTE_REG.test(route.urlPath)) {
-      dynamicRoutes.push(route);
-    } else {
-      normalRoutes.push(route);
-    }
-  });
-  const finalRoutes = [
-    ...normalRoutes.sort(sortRoutes),
-    ...dynamicRoutes.sort(sortRoutes)
-  ];
-  const router = new TrieRouter();
-  for (const route of finalRoutes) {
-    const { urlPath: originUrlPath } = route;
-    const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-    router.add("*", urlPath, route);
-  }
-  return router;
-}
-function matchRoute(router, pathname, entryName) {
-  const matched = router.match("*", pathname);
-  if (entryName && matched[0].length > 1) {
-    const matches = matched[0];
-    const result = matches.find(([route]) => route.entryName === entryName);
-    return result || [];
-  } else {
-    const result = matched[0][0];
-    return result || [];
-  }
-}
-function getHeadersWithoutCookie(headers) {
-  const _headers = {
-    ...headers,
-    cookie: void 0
-  };
-  delete _headers.cookie;
-  return _headers;
-}
-async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
-  const router = getRouter(routes);
-  return async (req, { logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext }) => {
-    const forMatchpathname = matchPathname !== null && matchPathname !== void 0 ? matchPathname : getPathname(req);
-    const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
-    const framework = cutNameByHyphen(metaName || "modern-js");
-    const fallbackHeader = `x-${framework}-ssr-fallback`;
-    let fallbackReason = null;
-    const fallbackWrapper = async (reason, error) => {
-      fallbackReason = reason;
-      return onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason, {
-        logger,
-        reporter,
-        metrics
-      }, error);
-    };
-    if (!routeInfo) {
-      return new Response(createErrorHtml(404), {
-        status: 404,
-        headers: {
-          "content-type": "text/html; charset=UTF-8"
-        }
-      });
-    }
-    const html = templates[uniqueKeyByRoute(routeInfo)];
-    if (!html) {
-      return new Response(createErrorHtml(404), {
-        status: 404,
-        headers: {
-          "content-type": "text/html; charset=UTF-8"
-        }
-      });
-    }
-    var _forceCSRMap_get;
-    const finalForceCSR = routeInfo.entryName ? (_forceCSRMap_get = forceCSRMap === null || forceCSRMap === void 0 ? void 0 : forceCSRMap.get(routeInfo.entryName)) !== null && _forceCSRMap_get !== void 0 ? _forceCSRMap_get : forceCSR : forceCSR;
-    const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper);
-    const headerData = parseHeaders(req);
-    const onError = (e, key) => {
-      monitors === null || monitors === void 0 ? void 0 : monitors.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
-    };
-    const onTiming = (name, dur) => {
-      monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
-    };
-    const renderOptions = {
-      pwd,
-      html,
-      routeInfo,
-      staticGenerate: staticGenerate || false,
-      config,
-      nodeReq,
-      cacheConfig,
-      reporter,
-      serverRoutes: routes,
-      params,
-      logger,
-      metrics,
-      monitors,
-      locals,
-      rscClientManifest,
-      rscSSRManifest,
-      rscServerManifest,
-      serverManifest,
-      loaderContext: loaderContext || /* @__PURE__ */ new Map(),
-      onError,
-      onTiming
-    };
-    if (fallbackReason) {
-      renderOptions.html = injectFallbackReasonToHtml({
-        html: renderOptions.html,
-        reason: fallbackReason,
-        framework
-      });
-    }
-    let response;
-    switch (renderMode) {
-      case "data":
-        response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", fallbackWrapper, framework);
-        break;
-      case "rsc-tree":
-        response = await renderRscHandler(req, renderOptions);
-        break;
-      case "rsc-action":
-        response = await serverActionHandler(req, renderOptions);
-        break;
-      case "ssr":
-      case "csr":
-        response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
-        break;
-      default:
-        throw new Error(`Unknown render mode: ${renderMode}`);
-    }
-    if (fallbackReason) {
-      response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
-    }
-    return response;
-  };
-}
-async function renderHandler(request, options, mode, fallbackWrapper, framework) {
-  var _options_config_server;
-  let response = null;
-  const { serverManifest } = options;
-  const ssrByRouteIds = (_options_config_server = options.config.server) === null || _options_config_server === void 0 ? void 0 : _options_config_server.ssrByRouteIds;
-  const runtimeEnv = getRuntimeEnv();
-  if (serverManifest.nestedRoutesJson && ssrByRouteIds && (ssrByRouteIds === null || ssrByRouteIds === void 0 ? void 0 : ssrByRouteIds.length) > 0 && runtimeEnv === "node") {
-    const { nestedRoutesJson } = serverManifest;
-    const routes = nestedRoutesJson === null || nestedRoutesJson === void 0 ? void 0 : nestedRoutesJson[options.routeInfo.entryName];
-    if (routes) {
-      const urlPath = "node:url";
-      const { pathToFileURL } = await import(urlPath);
-      const { matchRoutes } = await import(pathToFileURL(require.resolve("@modern-js/runtime-utils/remix-router")).href);
-      const url = new URL(request.url);
-      const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
-      if (!matchedRoutes) {
-        response = await csrRender(request, options);
-      } else {
-        var _lastMatch_route;
-        const lastMatch = matchedRoutes[matchedRoutes.length - 1];
-        if (!(lastMatch === null || lastMatch === void 0 ? void 0 : (_lastMatch_route = lastMatch.route) === null || _lastMatch_route === void 0 ? void 0 : _lastMatch_route.id) || !ssrByRouteIds.includes(lastMatch.route.id)) {
-          response = await csrRender(request, options);
-        }
-      }
-    }
-  }
-  if (mode === "ssr" && !response) {
-    try {
-      response = await ssrRender(request, options);
-    } catch (e) {
-      options.onError(e, ErrorDigest.ERENDER);
-      await fallbackWrapper("error", e);
-      response = await csrRender(request, {
-        ...options,
-        html: injectFallbackReasonToHtml({
-          html: options.html,
-          reason: "error",
-          framework
-        })
-      });
-    }
-  } else {
-    response = await csrRender(request, options);
-  }
-  const { routeInfo } = options;
-  applyExtendHeaders(response, routeInfo);
-  return response;
-  function applyExtendHeaders(r, route) {
-    Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
-      r.headers.set(k, v);
-    });
-  }
-}
-async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback) {
-  const query = parseQuery(req);
-  if (req.headers.get("x-rsc-action")) {
-    return "rsc-action";
-  }
-  if (req.headers.get("x-rsc-tree")) {
-    return "rsc-tree";
-  }
-  if (isSSR) {
-    if (query.__loader) {
-      return "data";
-    }
-    const fallbackHeaderValue = req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]);
-    if (forceCSR && (query.csr || fallbackHeaderValue)) {
-      if (query.csr) {
-        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("query"));
-      } else {
-        var _fallbackHeaderValue_split_;
-        const reason = fallbackHeaderValue === null || fallbackHeaderValue === void 0 ? void 0 : (_fallbackHeaderValue_split_ = fallbackHeaderValue.split(";")[1]) === null || _fallbackHeaderValue_split_ === void 0 ? void 0 : _fallbackHeaderValue_split_.split("=")[1];
-        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason ? `header,${reason}` : "header"));
-      }
-      return "csr";
-    }
-    return "ssr";
-  } else {
-    return "csr";
-  }
-}
-function injectFallbackReasonToHtml({ html, reason, framework }) {
-  const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
-    reason
-  })}</script>`;
-  return html.replace(/<\/head>/, `${tag}</head>`);
-}
-async function csrRender(request, options) {
-  const { html, rscClientManifest } = options;
-  if (!rscClientManifest || process.env.MODERN_DISABLE_INJECT_RSC_DATA) {
-    return new Response(html, {
-      status: 200,
-      headers: new Headers({
-        "content-type": "text/html; charset=UTF-8",
-        [X_MODERNJS_RENDER]: "client"
-      })
-    });
-  } else {
-    return csrRscRender(request, options);
-  }
-}
-export {
-  createRender
-};

package/dist/esm-node/plugins/render/renderRscHandler.js

@@ -1,52 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { createRequestHandlerConfig } from "./utils";
-const renderRscHandler = async (req, options) => {
-  var _serverManifest_renderBundles;
-  const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, logger, metrics, onError, onTiming, staticGenerate } = options;
-  const serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
-  const loadableStats = serverManifest.loadableStats || {};
-  const routeManifest = serverManifest.routeManifest || {};
-  const config = createRequestHandlerConfig(options.config);
-  const requestHandlerOptions = {
-    resource: {
-      route: routeInfo,
-      loadableStats,
-      routeManifest,
-      entryName: routeInfo.entryName || MAIN_ENTRY_NAME
-    },
-    config,
-    params,
-    loaderContext,
-    rscSSRManifest,
-    rscClientManifest,
-    rscServerManifest,
-    locals,
-    reporter,
-    staticGenerate,
-    logger,
-    metrics,
-    monitors,
-    onError,
-    onTiming
-  };
-  if (!serverBundle) {
-    return new Response("Cannot find server bundle for RSC", {
-      status: 500
-    });
-  }
-  const rscPayloadHandler = await serverBundle.rscPayloadHandler;
-  if (!rscPayloadHandler) {
-    return new Response("Cannot find request handler for RSC", {
-      status: 500
-    });
-  }
-  if (!rscClientManifest) {
-    return new Response("Cannot find rsc client manifest", {
-      status: 500
-    });
-  }
-  return rscPayloadHandler(req, requestHandlerOptions);
-};
-export {
-  renderRscHandler
-};

package/dist/esm-node/plugins/render/serverActionHandler.js

@@ -1,27 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-const serverActionHandler = async (req, { serverManifest, routeInfo, rscClientManifest }) => {
-  var _serverManifest_renderBundles;
-  const serverBundle = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
-  if (!serverBundle) {
-    return new Response("Cannot find server bundle for server action", {
-      status: 500
-    });
-  }
-  const { handleAction } = serverBundle;
-  if (!handleAction) {
-    return new Response("Cannot find server action handler", {
-      status: 500
-    });
-  }
-  if (!rscClientManifest) {
-    return new Response("Cannot find rsc client manifest", {
-      status: 500
-    });
-  }
-  return handleAction(req, {
-    clientManifest: rscClientManifest
-  });
-};
-export {
-  serverActionHandler
-};

package/dist/esm-node/plugins/render/ssrCache.js

@@ -1,190 +0,0 @@
-import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { X_RENDER_CACHE } from "../../constants";
-import { createTransformStream, getPathname } from "../../utils";
-const removeTailSlash = (s) => s.replace(/\/+$/, "");
-const ZERO_RENDER_LEVEL = /"renderLevel":0/;
-const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
-async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
-  const response = await requestHandler(request, requestHandlerOptions);
-  const { onError } = requestHandlerOptions;
-  const nonCacheableStatusCodes = [
-    204,
-    305,
-    404,
-    405,
-    500,
-    501,
-    502,
-    503,
-    504
-  ];
-  if (nonCacheableStatusCodes.includes(response.status)) {
-    return response;
-  }
-  const decoder = new TextDecoder();
-  if (response.body) {
-    const stream = createTransformStream();
-    const reader = response.body.getReader();
-    const writer = stream.writable.getWriter();
-    let html = "";
-    const push = () => reader.read().then(({ done, value }) => {
-      if (done) {
-        const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
-        if (match) {
-          writer.close();
-          return;
-        }
-        const current = Date.now();
-        const cache = {
-          val: html,
-          cursor: current
-        };
-        container.set(key, JSON.stringify(cache), {
-          ttl
-        }).catch(() => {
-          if (onError) {
-            onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-          } else {
-            console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-          }
-        });
-        writer.close();
-        return;
-      }
-      const content = decoder.decode(value);
-      html += content;
-      writer.write(value);
-      push();
-    });
-    push();
-    cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
-    return new Response(stream.readable, {
-      status: response.status,
-      headers: response.headers
-    });
-  }
-  return response;
-}
-const CACHE_NAMESPACE = "__ssr__cache";
-const storage = createMemoryStorage(CACHE_NAMESPACE);
-function computedKey(req, cacheControl) {
-  const pathname = getPathname(req);
-  const { customKey } = cacheControl;
-  const defaultKey = pathname === "/" ? pathname : removeTailSlash(pathname);
-  if (customKey) {
-    if (typeof customKey === "string") {
-      return customKey;
-    } else {
-      return customKey(defaultKey);
-    }
-  } else {
-    return defaultKey;
-  }
-}
-function shouldUseCache(request) {
-  const url = new URL(request.url);
-  const hasRSCAction = request.headers.has("x-rsc-action");
-  const hasRSCTree = request.headers.has("x-rsc-tree");
-  const hasLoaderQuery = url.searchParams.has("__loader");
-  return !(hasRSCAction || hasRSCTree || hasLoaderQuery);
-}
-function matchCacheControl(cacheOption, req) {
-  if (!cacheOption || !req) {
-    return void 0;
-  } else if (isCacheControl(cacheOption)) {
-    return cacheOption;
-  } else if (isCacheOptionProvider(cacheOption)) {
-    return cacheOption(req);
-  } else {
-    const url = req.url;
-    const options = Object.entries(cacheOption);
-    for (const [key, option] of options) {
-      if (key === "*" || new RegExp(key).test(url)) {
-        if (typeof option === "function") {
-          return option(req);
-        } else {
-          return option;
-        }
-      }
-    }
-    return void 0;
-  }
-  function isCacheOptionProvider(option) {
-    return typeof option === "function";
-  }
-  function isCacheControl(option) {
-    return typeof option === "object" && option !== null && "maxAge" in option;
-  }
-}
-async function getCacheResult(request, options) {
-  const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
-  const { onError } = requestHandlerOptions;
-  const key = computedKey(request, cacheControl);
-  let value;
-  try {
-    value = await container.get(key);
-  } catch (_) {
-    if (onError) {
-      onError(`[render-cache] get cache failed, key: ${key}`);
-    } else {
-      console.error(`[render-cache] get cache failed, key: ${key}`);
-    }
-    value = void 0;
-  }
-  const { maxAge, staleWhileRevalidate } = cacheControl;
-  const ttl = maxAge + staleWhileRevalidate;
-  if (value) {
-    const cache = JSON.parse(value);
-    const interval = Date.now() - cache.cursor;
-    if (interval <= maxAge) {
-      const cacheStatus = "hit";
-      return new Response(cache.val, {
-        headers: {
-          [X_RENDER_CACHE]: cacheStatus
-        }
-      });
-    } else if (interval <= staleWhileRevalidate + maxAge) {
-      processCache({
-        key,
-        request,
-        requestHandler,
-        requestHandlerOptions,
-        ttl,
-        container
-      }).then(async (response) => {
-        await response.text();
-      });
-      const cacheStatus = "stale";
-      return new Response(cache.val, {
-        headers: {
-          [X_RENDER_CACHE]: cacheStatus
-        }
-      });
-    } else {
-      return processCache({
-        key,
-        request,
-        requestHandler,
-        requestHandlerOptions,
-        ttl,
-        container,
-        cacheStatus: "expired"
-      });
-    }
-  } else {
-    return processCache({
-      key,
-      request,
-      requestHandler,
-      requestHandlerOptions,
-      ttl,
-      container,
-      cacheStatus: "miss"
-    });
-  }
-}
-export {
-  getCacheResult,
-  matchCacheControl,
-  shouldUseCache
-};

package/dist/esm-node/plugins/render/ssrRender.js

@@ -1,77 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { X_MODERNJS_RENDER } from "../../constants";
-import { getPathname, parseHeaders } from "../../utils";
-import { getCacheResult, matchCacheControl, shouldUseCache } from "./ssrCache";
-import { createRequestHandlerConfig } from "./utils";
-const SERVER_RUNTIME_ENTRY = "requestHandler";
-async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, cacheConfig, logger, metrics, onError, onTiming }) {
-  var _serverManifest_renderBundles;
-  const { entryName } = routeInfo;
-  const loadableStats = serverManifest.loadableStats || {};
-  const routeManifest = serverManifest.routeManifest || {};
-  const headers = parseHeaders(request);
-  if (nodeReq) {
-    for (const key in nodeReq.headers) {
-      if (!headers[key]) {
-        headers[key] = nodeReq.headers[key];
-      }
-    }
-  }
-  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
-  if (!renderBundle) {
-    throw new Error(`Can't find renderBundle ${entryName || MAIN_ENTRY_NAME}`);
-  }
-  const requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
-  const config = createRequestHandlerConfig(userConfig);
-  const requestHandlerOptions = {
-    resource: {
-      route: routeInfo,
-      loadableStats,
-      routeManifest,
-      htmlTemplate: html,
-      entryName: entryName || MAIN_ENTRY_NAME
-    },
-    params,
-    loaderContext,
-    config,
-    rscSSRManifest,
-    rscClientManifest,
-    rscServerManifest,
-    locals,
-    reporter,
-    staticGenerate,
-    logger,
-    metrics,
-    monitors,
-    onError,
-    onTiming
-  };
-  const cacheControl = await matchCacheControl(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
-  let response;
-  if (cacheControl && shouldUseCache(request)) {
-    response = await getCacheResult(request, {
-      cacheControl,
-      container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
-      requestHandler,
-      requestHandlerOptions
-    });
-  } else {
-    response = await requestHandler(request, requestHandlerOptions);
-  }
-  response.headers.set(X_MODERNJS_RENDER, "server");
-  response.headers.set("content-type", "text/html; charset=UTF-8");
-  return response;
-}
-class IncomingMessgeProxy {
-  constructor(req) {
-    this.headers = {};
-    req.headers.forEach((value, key) => {
-      this.headers[key] = value;
-    });
-    this.method = req.method;
-    this.url = getPathname(req);
-  }
-}
-export {
-  ssrRender
-};

package/dist/esm-node/plugins/render/utils.js

@@ -1,17 +0,0 @@
-function createRequestHandlerConfig(userConfig) {
-  const { output, server, security, html, source } = userConfig;
-  return {
-    ssr: server === null || server === void 0 ? void 0 : server.ssr,
-    ssrByEntries: server === null || server === void 0 ? void 0 : server.ssrByEntries,
-    nonce: security === null || security === void 0 ? void 0 : security.nonce,
-    enableInlineScripts: output === null || output === void 0 ? void 0 : output.enableInlineScripts,
-    enableInlineStyles: output === null || output === void 0 ? void 0 : output.enableInlineStyles,
-    crossorigin: html === null || html === void 0 ? void 0 : html.crossorigin,
-    scriptLoading: html === null || html === void 0 ? void 0 : html.scriptLoading,
-    useJsonScript: server === null || server === void 0 ? void 0 : server.useJsonScript,
-    enableAsyncEntry: source === null || source === void 0 ? void 0 : source.enableAsyncEntry
-  };
-}
-export {
-  createRequestHandlerConfig
-};

package/dist/esm-node/plugins/route.js

@@ -1,41 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import { sortRoutes } from "../utils";
-function injectRoute(route) {
-  return async (c, next) => {
-    if (route && !c.get("route")) {
-      c.set("route", route);
-    }
-    await next();
-  };
-}
-function getPageRoutes(routes) {
-  return routes.filter((route) => route.entryName).sort(sortRoutes);
-}
-const injectRoutePlugin = () => ({
-  name: "@modern-js/plugin-inject-route",
-  setup(api) {
-    return {
-      async prepare() {
-        const { middlewares, routes } = api.useAppContext();
-        if (!routes) {
-          return;
-        }
-        const pageRoutes = getPageRoutes(routes);
-        for (const route of pageRoutes) {
-          const { urlPath: originUrlPath, entryName = MAIN_ENTRY_NAME } = route;
-          const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-          middlewares.push({
-            name: "inject-route-info",
-            path: urlPath,
-            handler: injectRoute({
-              entryName
-            })
-          });
-        }
-      }
-    };
-  }
-});
-export {
-  injectRoutePlugin
-};