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

package/dist/esm-node/adapters/node/helper/loadConfig.js

@@ -1,59 +0,0 @@
-import path from "path";
-import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, chalk, compatibleRequire, ensureAbsolutePath, getMeta, requireExistModule } from "@modern-js/utils";
-import { parse } from "flatted";
-const requireConfig = async (serverConfigPath) => {
-  if (fs.pathExistsSync(serverConfigPath)) {
-    return compatibleRequire(serverConfigPath);
-  }
-  return void 0;
-};
-async function loadServerConfigNew(serverConfigPath) {
-  const mod = await requireExistModule(serverConfigPath);
-  if (mod) {
-    return mod;
-  }
-  return void 0;
-}
-async function loadServerConfigOld(pwd, configFile) {
-  const serverConfigPath = path.join(pwd, `${configFile}.cjs`);
-  const serverConfig = await requireConfig(serverConfigPath);
-  return serverConfig;
-}
-async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath, metaName) {
-  const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
-  if (newServerConfig) {
-    return newServerConfig;
-  }
-  const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
-  if (oldServerConfig) {
-    const meta = getMeta(metaName);
-    console.warn(`${chalk.red("\n[Warning]")} ${chalk.yellow.bold(`\`${oldServerFile}\``)} is no longer maintained. To extend the server, please migrate to ${chalk.yellow.bold(`\`server/${meta}.server.ts\``)};`);
-  }
-  return oldServerConfig;
-}
-function loadServerCliConfig(pwd, defaultConfig = {}) {
-  var _defaultConfig_output_distPath, _defaultConfig_output;
-  const cliConfigPath = ensureAbsolutePath(pwd, path.join(((_defaultConfig_output = defaultConfig.output) === null || _defaultConfig_output === void 0 ? void 0 : (_defaultConfig_output_distPath = _defaultConfig_output.distPath) === null || _defaultConfig_output_distPath === void 0 ? void 0 : _defaultConfig_output_distPath.root) || "dist", OUTPUT_CONFIG_FILE));
-  let cliConfig = {
-    output: {},
-    source: {},
-    tools: {},
-    server: {},
-    security: {},
-    runtime: {},
-    bff: {},
-    html: {},
-    dev: {}
-  };
-  try {
-    const content = fs.readFileSync(cliConfigPath, "utf-8");
-    cliConfig = parse(content);
-  } catch (_2) {
-  }
-  const mergedCliConfig = _.merge(defaultConfig, cliConfig);
-  return mergedCliConfig;
-}
-export {
-  loadServerCliConfig,
-  loadServerRuntimeConfig
-};

package/dist/esm-node/adapters/node/helper/loadEnv.js

@@ -1,22 +0,0 @@
-import path from "path";
-import { fs, dotenv, dotenvExpand } from "@modern-js/utils";
-async function loadServerEnv(options) {
-  const { pwd } = options;
-  const serverEnv = process.env.MODERN_ENV;
-  const defaultEnvPath = path.resolve(pwd, `.env`);
-  const serverEnvPath = path.resolve(pwd, `.env.${serverEnv}`);
-  for (const envPath of [
-    serverEnvPath,
-    defaultEnvPath
-  ]) {
-    if (await fs.pathExists(envPath) && !(await fs.stat(envPath)).isDirectory()) {
-      const envConfig = dotenv.config({
-        path: envPath
-      });
-      dotenvExpand(envConfig);
-    }
-  }
-}
-export {
-  loadServerEnv
-};

package/dist/esm-node/adapters/node/helper/loadPlugin.js

@@ -1,15 +0,0 @@
-import { compatibleRequire, tryResolve } from "@modern-js/utils";
-async function resolveServerPlugin(plugin, appDirectory) {
-  const { name, options } = plugin;
-  const pluginPath = tryResolve(name, appDirectory);
-  const module = await compatibleRequire(pluginPath);
-  const pluginInstance = module(options);
-  return pluginInstance;
-}
-async function loadServerPlugins(serverPlugins, appDirectory) {
-  const instances = await Promise.all(serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory)));
-  return instances;
-}
-export {
-  loadServerPlugins
-};

package/dist/esm-node/adapters/node/helper/utils.js

@@ -1,7 +0,0 @@
-const isResFinalized = (res) => {
-  var _res_socket;
-  return res.headersSent || res._modernBodyPiped || res.writableEnded || res.finished || !((_res_socket = res.socket) === null || _res_socket === void 0 ? void 0 : _res_socket.writable);
-};
-export {
-  isResFinalized
-};

package/dist/esm-node/adapters/node/hono.js

@@ -1,79 +0,0 @@
-import { isResFinalized } from "./helper";
-const httpCallBack2HonoMid = (handler) => {
-  return async (context, next) => {
-    const { req, res } = context.env.node;
-    const onPipe = () => {
-      res._modernBodyPiped = true;
-    };
-    res.once("pipe", onPipe);
-    req.__honoRequest = context.req;
-    req.__templates = context.get("templates") || {};
-    req.__serverManifest = context.get("serverManifest") || {};
-    req.__rscServerManifest = context.get("rscServerManifest");
-    req.__rscClientManifest = context.get("rscClientManifest");
-    req.__rscSSRManifest = context.get("rscSSRManifest");
-    try {
-      await handler(req, res);
-    } finally {
-      delete req.__honoRequest;
-      delete req.__templates;
-      delete req.__serverManifest;
-      delete req.__rscServerManifest;
-      delete req.__rscClientManifest;
-      delete req.__rscSSRManifest;
-      res.removeListener("pipe", onPipe);
-    }
-    if (isResFinalized(res)) {
-      context.finalized = true;
-    } else {
-      await next();
-    }
-  };
-};
-const noop = () => {
-};
-const connectMid2HonoMid = (handler) => {
-  return async (context, next) => {
-    return new Promise((resolve, reject) => {
-      const { req, res } = context.env.node;
-      if (handler.length < 3) {
-        resolve(handler(req, res, noop));
-      } else {
-        handler(req, res, (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(next());
-          }
-        });
-      }
-    });
-  };
-};
-const connectMockMid2HonoMid = (handler) => {
-  return async (context, next) => {
-    return new Promise((resolve, reject) => {
-      const { req, res } = context.env.node;
-      if (handler.length < 3) {
-        res.once("finish", () => {
-          context.finalized = true;
-          resolve();
-        });
-        handler(req, res, noop);
-      } else {
-        handler(req, res, (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(next());
-          }
-        });
-      }
-    });
-  };
-};
-export {
-  connectMid2HonoMid,
-  connectMockMid2HonoMid,
-  httpCallBack2HonoMid
-};

package/dist/esm-node/adapters/node/index.js

@@ -1,23 +0,0 @@
-import { httpCallBack2HonoMid, connectMid2HonoMid, connectMockMid2HonoMid } from "./hono";
-import { createNodeServer, sendResponse, createWebRequest } from "./node";
-import { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectRscManifestPlugin } from "./plugins";
-import { loadServerPlugins, loadServerEnv, loadServerRuntimeConfig, loadServerCliConfig, loadCacheConfig } from "./helper";
-export {
-  connectMid2HonoMid,
-  connectMockMid2HonoMid,
-  createNodeServer,
-  createWebRequest,
-  getHtmlTemplates,
-  getServerManifest,
-  httpCallBack2HonoMid,
-  injectNodeSeverPlugin,
-  injectResourcePlugin,
-  injectRscManifestPlugin,
-  loadCacheConfig,
-  loadServerCliConfig,
-  loadServerEnv,
-  loadServerPlugins,
-  loadServerRuntimeConfig,
-  sendResponse,
-  serverStaticPlugin
-};

package/dist/esm-node/adapters/node/node.js

@@ -1,169 +0,0 @@
-import { ServerResponse } from "node:http";
-import { Readable, Writable } from "node:stream";
-import cloneable from "cloneable-readable";
-import { isResFinalized } from "./helper";
-const createWebRequest = (req, res, body) => {
-  const headerRecord = [];
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (key.startsWith(":")) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item !== void 0) {
-          headerRecord.push([
-            key,
-            item
-          ]);
-        }
-      }
-    } else if (value !== void 0) {
-      if (typeof value === "string") {
-        headerRecord.push([
-          key,
-          value
-        ]);
-      }
-    }
-  }
-  const { method } = req;
-  const controller = new AbortController();
-  const init = {
-    method,
-    headers: headerRecord,
-    signal: controller.signal
-  };
-  res.on("close", () => controller.abort("res closed"));
-  const url = `http://${req.headers.host}${req.url}`;
-  const needsRequestBody = body || !(method === "GET" || method === "HEAD");
-  const cloneableReq = needsRequestBody ? cloneable(req) : null;
-  if (needsRequestBody) {
-    if (body) {
-      init.body = body;
-    } else {
-      const stream = cloneableReq.clone();
-      init.body = Readable.toWeb(stream);
-    }
-    init.duplex = "half";
-  }
-  const originalRequest = new Request(url, init);
-  if (needsRequestBody) {
-    const interceptedMethods = [
-      "json",
-      "text",
-      "blob",
-      "arrayBuffer",
-      "formData"
-    ];
-    return new Proxy(originalRequest, {
-      get(target, prop) {
-        if (interceptedMethods.includes(prop)) {
-          return (...args) => {
-            cloneableReq.resume();
-            return target[prop].call(target, ...args);
-          };
-        }
-        const value = target[prop];
-        if (prop === "body") {
-          cloneableReq.resume();
-          return value;
-        }
-        if (typeof value === "function") {
-          return (...args) => value.apply(target, args);
-        }
-        return value;
-      }
-    });
-  }
-  return originalRequest;
-};
-const sendResponse = async (response, res) => {
-  var _response_headers_get;
-  res.statusMessage = response.statusText;
-  res.statusCode = response.status;
-  const cookies = [];
-  for (const [key, value] of response.headers.entries()) {
-    if (key === "set-cookie") {
-      cookies.push(value);
-    } else {
-      res.setHeader(key, value);
-    }
-  }
-  if (cookies.length > 0) {
-    res.setHeader("set-cookie", cookies);
-  }
-  if (((_response_headers_get = response.headers.get("Content-Type")) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.match(/text\/event-stream/i)) && res instanceof ServerResponse) {
-    res.flushHeaders();
-  }
-  if (response.body) {
-    const writable = Writable.toWeb(res);
-    await response.body.pipeTo(writable);
-  } else {
-    res.end();
-  }
-};
-const handleResponseError = (e, res) => {
-  const err = e instanceof Error ? e : new Error("unknown error", {
-    cause: e
-  });
-  if (err.code === "ABORT_ERR" || err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!res.headersSent) {
-      res.writeHead(500, {
-        "Content-Type": "text/plain"
-      });
-    }
-    res.end(`Error: ${err.message}`);
-    res.destroy(err);
-  }
-};
-const getRequestListener = (handler) => {
-  return async (req, res) => {
-    try {
-      const request = createWebRequest(req, res);
-      const response = await handler(request, {
-        node: {
-          req,
-          res
-        }
-      });
-      if (!response.res && !isResFinalized(res)) {
-        await sendResponse(response, res);
-      }
-    } catch (error) {
-      return handleResponseError(error, res);
-    }
-  };
-};
-const createNodeServer = async (requestHandler, httpsOptions, http2) => {
-  const requestListener = getRequestListener(requestHandler);
-  let nodeServer;
-  if (httpsOptions) {
-    if (http2) {
-      const { createSecureServer } = await import("node:http2");
-      nodeServer = createSecureServer({
-        allowHTTP1: true,
-        maxSessionMemory: 1024,
-        ...httpsOptions
-      }, (req, res) => {
-        return requestListener(req, res);
-      });
-    } else {
-      const { createServer } = await import("node:https");
-      nodeServer = createServer(httpsOptions, requestListener);
-    }
-  } else {
-    const { createServer } = await import("node:http");
-    nodeServer = createServer(requestListener);
-  }
-  nodeServer.getRequestListener = () => requestListener;
-  nodeServer.getRequestHandler = () => requestHandler;
-  return nodeServer;
-};
-export {
-  createNodeServer,
-  createWebRequest,
-  sendResponse
-};

package/dist/esm-node/adapters/node/plugins/nodeServer.js

@@ -1,14 +0,0 @@
-const injectNodeSeverPlugin = ({ nodeServer }) => ({
-  name: "@modern-js/plugin-inject-node-server",
-  setup(api) {
-    const appContext = api.useAppContext();
-    api.setAppContext({
-      ...appContext,
-      nodeServer
-    });
-    return {};
-  }
-});
-export {
-  injectNodeSeverPlugin
-};

package/dist/esm-node/adapters/node/plugins/resource.js

@@ -1,159 +0,0 @@
-import path from "path";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs, LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, compatibleRequire, isProd } from "@modern-js/utils";
-import { uniqueKeyByRoute } from "../../../utils";
-async function getHtmlTemplates(pwd, routes) {
-  const htmlRoutes = routes.filter((route) => route.entryName);
-  const htmls = await Promise.all(htmlRoutes.map(async (route) => {
-    let html;
-    try {
-      var _this;
-      const htmlPath = path.join(pwd, route.entryPath);
-      html = (_this = await fileReader.readFile(htmlPath, "utf-8")) === null || _this === void 0 ? void 0 : _this.toString();
-    } catch (e) {
-    }
-    return [
-      uniqueKeyByRoute(route),
-      html
-    ];
-  }) || []);
-  const templates = Object.fromEntries(htmls);
-  return templates;
-}
-function injectTemplates(pwd, routes, htmlTemplatePromise) {
-  return async (c, next) => {
-    if (routes && !c.get("templates")) {
-      const templates = await (htmlTemplatePromise || getHtmlTemplates(pwd, routes));
-      c.set("templates", templates);
-    }
-    await next();
-  };
-}
-const loadBundle = async (filepath, logger) => {
-  if (!await fs.pathExists(filepath)) {
-    return void 0;
-  }
-  try {
-    const module = await compatibleRequire(filepath, false);
-    return module;
-  } catch (e) {
-    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
-    return void 0;
-  }
-};
-async function getServerManifest(pwd, routes, logger) {
-  const loaderBundles = {};
-  const renderBundles = {};
-  await Promise.all(routes.filter((route) => Boolean(route.bundle)).map(async (route) => {
-    const entryName = route.entryName || MAIN_ENTRY_NAME;
-    const renderBundlePath = path.join(pwd, route.bundle || "");
-    const loaderBundlePath = path.join(pwd, SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
-    const renderBundle = await loadBundle(renderBundlePath, logger);
-    const loaderBundle = await loadBundle(loaderBundlePath, logger);
-    renderBundle && (renderBundles[entryName] = renderBundle);
-    loaderBundle && (loaderBundles[entryName] = (loaderBundle === null || loaderBundle === void 0 ? void 0 : loaderBundle.loadModules) ? await (loaderBundle === null || loaderBundle === void 0 ? void 0 : loaderBundle.loadModules()) : loaderBundle);
-  }));
-  const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
-  const loadableStats = await compatibleRequire(loadableUri).catch((_) => ({}));
-  const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
-  const routeManifest = await compatibleRequire(routesManifestUri).catch((_) => ({}));
-  const nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
-  const nestedRoutesJson = await compatibleRequire(nestedRoutesJsonPath).catch((_) => ({}));
-  return {
-    loaderBundles,
-    renderBundles,
-    loadableStats,
-    routeManifest,
-    nestedRoutesJson
-  };
-}
-function injectServerManifest(pwd, routes, manifestPromise) {
-  return async (c, next) => {
-    if (routes && !c.get("serverManifest")) {
-      const logger = c.get("logger");
-      const serverManifest = await (manifestPromise || getServerManifest(pwd, routes, logger));
-      c.set("serverManifest", serverManifest);
-    }
-    await next();
-  };
-}
-async function getRscServerManifest(pwd) {
-  const rscServerManifest = await compatibleRequire(path.join(pwd, "bundles", "react-server-manifest.json")).catch((_) => void 0);
-  return rscServerManifest;
-}
-async function getClientManifest(pwd) {
-  const rscClientManifest = await compatibleRequire(path.join(pwd, "react-client-manifest.json")).catch((_) => void 0);
-  return rscClientManifest;
-}
-async function getRscSSRManifest(pwd) {
-  const rscSSRManifest = await compatibleRequire(path.join(pwd, "react-ssr-manifest.json")).catch((_) => void 0);
-  return rscSSRManifest;
-}
-const injectRscManifestPlugin = () => ({
-  name: "@modern-js/plugin-inject-rsc-manifest",
-  setup(api) {
-    return {
-      async prepare() {
-        var _config_server;
-        const { middlewares, distDirectory: pwd } = api.useAppContext();
-        const config = api.useConfigContext();
-        if (!((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.rsc)) {
-          return;
-        }
-        middlewares.push({
-          name: "inject-rsc-manifest",
-          handler: async (c, next) => {
-            if (!c.get("rscServerManifest")) {
-              const rscServerManifest = await getRscServerManifest(pwd);
-              c.set("rscServerManifest", rscServerManifest);
-            }
-            if (!c.get("rscClientManifest")) {
-              const rscClientManifest = await getClientManifest(pwd);
-              c.set("rscClientManifest", rscClientManifest);
-            }
-            if (!c.get("rscSSRManifest")) {
-              const rscSSRManifest = await getRscSSRManifest(pwd);
-              c.set("rscSSRManifest", rscSSRManifest);
-            }
-            await next();
-          }
-        });
-      }
-    };
-  }
-});
-const injectResourcePlugin = () => ({
-  name: "@modern-js/plugin-inject-resource",
-  setup(api) {
-    return {
-      async prepare() {
-        const { middlewares, routes, distDirectory: pwd } = api.useAppContext();
-        let htmlTemplatePromise;
-        let manifestPromise;
-        if (isProd()) {
-          manifestPromise = getServerManifest(pwd, routes || [], console);
-          htmlTemplatePromise = getHtmlTemplates(pwd, routes || []);
-        }
-        middlewares.push({
-          name: "inject-server-manifest",
-          handler: injectServerManifest(pwd, routes, manifestPromise)
-        });
-        middlewares.push({
-          name: "inject-html",
-          handler: injectTemplates(pwd, routes, htmlTemplatePromise)
-        });
-      }
-    };
-  }
-});
-export {
-  getClientManifest,
-  getHtmlTemplates,
-  getRscSSRManifest,
-  getRscServerManifest,
-  getServerManifest,
-  injectResourcePlugin,
-  injectRscManifestPlugin,
-  injectServerManifest,
-  injectTemplates
-};

package/dist/esm-node/adapters/node/plugins/static.js

@@ -1,144 +0,0 @@
-import path from "path";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs } from "@modern-js/utils";
-import { getMimeType } from "hono/utils/mime";
-import { sortRoutes } from "../../../utils";
-const serverStaticPlugin = () => ({
-  name: "@modern-js/plugin-server-static",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares, distDirectory: pwd, routes } = api.useAppContext();
-        const config = api.useConfigContext();
-        const serverStaticMiddleware = createStaticMiddleware({
-          pwd,
-          routes,
-          output: config.output || {},
-          html: config.html || {}
-        });
-        middlewares.push({
-          name: "server-static",
-          handler: serverStaticMiddleware
-        });
-      }
-    };
-  }
-});
-function createPublicMiddleware({ pwd, routes }) {
-  return async (c, next) => {
-    const route = matchPublicRoute(c.req, routes);
-    if (route) {
-      const { entryPath } = route;
-      const filename = path.join(pwd, entryPath);
-      const data = await fileReader.readFile(filename, "buffer");
-      const mimeType = getMimeType(filename);
-      if (data !== null) {
-        if (mimeType) {
-          c.header("Content-Type", mimeType);
-        }
-        Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
-          c.header(k, v);
-        });
-        return c.body(data, 200);
-      }
-    }
-    return await next();
-  };
-}
-function matchPublicRoute(req, routes) {
-  for (const route of routes.sort(sortRoutes)) {
-    if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
-      return route;
-    }
-  }
-  return void 0;
-}
-const extractPathname = (url) => {
-  try {
-    if (url.includes("://")) {
-      return new URL(url).pathname || "/";
-    }
-    if (url.startsWith("//")) {
-      return new URL(`http:${url}`).pathname || "/";
-    }
-    return url;
-  } catch (e) {
-    return url;
-  }
-};
-function createStaticMiddleware(options) {
-  const { pwd, routes } = options;
-  const prefix = options.output.assetPrefix || "/";
-  const pathPrefix = extractPathname(prefix);
-  const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
-  const { favicon, faviconByEntries } = options.html;
-  const favicons = prepareFavicons(favicon, faviconByEntries);
-  const staticFiles = [
-    cssPath,
-    jsPath,
-    mediaPath
-  ].filter((v) => Boolean(v));
-  const staticReg = [
-    "static/",
-    "upload/",
-    ...staticFiles
-  ];
-  const iconReg = [
-    "favicon.ico",
-    "icon.png",
-    ...favicons
-  ];
-  const regPrefix = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
-  const staticPathRegExp = new RegExp(`^${regPrefix}(${[
-    ...staticReg,
-    ...iconReg
-  ].join("|")})`);
-  return async (c, next) => {
-    const pageRoute = c.get("route");
-    const pathname = c.req.path;
-    if (pageRoute && path.extname(pathname) === "") {
-      return next();
-    }
-    const hit = staticPathRegExp.test(pathname);
-    if (hit) {
-      const filepath = path.join(pwd, pathname.replace(pathPrefix, () => ""));
-      if (!await fs.pathExists(filepath)) {
-        return next();
-      }
-      const mimeType = getMimeType(filepath);
-      if (mimeType) {
-        c.header("Content-Type", mimeType);
-      }
-      const stat = await fs.lstat(filepath);
-      const { size } = stat;
-      const chunk = await fileReader.readFileFromSystem(filepath, "buffer");
-      c.header("Content-Length", String(size));
-      return c.body(chunk, 200);
-    } else {
-      return createPublicMiddleware({
-        pwd,
-        routes: routes || []
-      })(c, next);
-    }
-  };
-}
-const prepareFavicons = (favicon, faviconByEntries) => {
-  const faviconNames = [];
-  if (favicon && typeof favicon === "string") {
-    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
-  }
-  if (faviconByEntries) {
-    Object.keys(faviconByEntries).forEach((f) => {
-      const curFavicon = faviconByEntries[f];
-      if (curFavicon) {
-        faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
-      }
-    });
-  }
-  return faviconNames;
-};
-export {
-  createPublicMiddleware,
-  createStaticMiddleware,
-  serverStaticPlugin
-};