@modern-js/plugin-ssg 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/server/index.mjs

@@ -0,0 +1,97 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import path from "path";
+import { createProdServer, loadServerPlugins } from "@modern-js/prod-server";
+import { SERVER_DIR, createLogger, getMeta, logger } from "@modern-js/utils";
+import { chunkArray, openRouteSSR } from "../libs/util.mjs";
+function getLogger() {
+    const l = createLogger({
+        level: 'verbose'
+    });
+    return {
+        ...l,
+        error: (...args)=>{
+            console.error(...args);
+        }
+    };
+}
+const MAX_CONCURRENT_REQUESTS = 10;
+function createMockIncomingMessage(url, headers = {}) {
+    const urlObj = new URL(url);
+    const mockReq = new IncomingMessage({});
+    mockReq.url = urlObj.pathname + urlObj.search;
+    mockReq.method = 'GET';
+    mockReq.headers = {
+        host: urlObj.host,
+        'user-agent': 'SSG-Renderer/1.0',
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'accept-language': 'en-US,en;q=0.5',
+        'accept-encoding': 'gzip, deflate',
+        connection: 'keep-alive',
+        ...headers
+    };
+    mockReq.httpVersion = '1.1';
+    mockReq.httpVersionMajor = 1;
+    mockReq.httpVersionMinor = 1;
+    mockReq.complete = true;
+    mockReq.rawHeaders = [];
+    mockReq.socket = {};
+    mockReq.connection = mockReq.socket;
+    return mockReq;
+}
+function createMockServerResponse() {
+    const mockRes = new ServerResponse({});
+    return mockRes;
+}
+const createServer = async (appContext, ssgRoutes, pageRoutes, apiRoutes, options)=>{
+    const entries = ssgRoutes.map((route)=>route.entryName);
+    const backup = openRouteSSR(pageRoutes, entries);
+    const total = backup.concat(apiRoutes);
+    try {
+        const meta = getMeta(appContext.metaName);
+        const distDirectory = appContext.distDirectory;
+        const serverConfigPath = path.resolve(distDirectory, SERVER_DIR, `${meta}.server`);
+        const plugins = appContext.serverPlugins;
+        const serverOptions = {
+            pwd: distDirectory,
+            config: options,
+            appContext,
+            serverConfigPath,
+            routes: total,
+            plugins: await loadServerPlugins(plugins, appContext.appDirectory || distDirectory),
+            staticGenerate: true,
+            logger: getLogger()
+        };
+        const nodeServer = await createProdServer(serverOptions);
+        const requestHandler = nodeServer.getRequestHandler();
+        const chunkedRoutes = chunkArray(ssgRoutes, MAX_CONCURRENT_REQUESTS);
+        const results = [];
+        for (const routes of chunkedRoutes){
+            const promises = routes.map(async (route)=>{
+                const url = `http://localhost${route.urlPath}`;
+                const request = new Request(url, {
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost',
+                        'x-modern-ssg-render': 'true'
+                    }
+                });
+                const mockReq = createMockIncomingMessage(url);
+                const mockRes = createMockServerResponse();
+                const response = await requestHandler(request, {
+                    node: {
+                        req: mockReq,
+                        res: mockRes
+                    }
+                });
+                return await response.text();
+            });
+            const batch = await Promise.all(promises);
+            results.push(...batch);
+        }
+        return results;
+    } catch (e) {
+        logger.error(e instanceof Error ? e.stack : e.toString());
+        throw new Error('ssg render failed');
+    }
+};
+export { createServer };

package/dist/esm-node/server/prerender.mjs

@@ -0,0 +1,30 @@
+import events from "events";
+import { Readable } from "stream";
+import node_mocks_http from "node-mocks-http";
+const compile = (requestHandler)=>(options, extend = {})=>new Promise((resolve, reject)=>{
+            const req = node_mocks_http.createRequest({
+                ...options,
+                eventEmitter: Readable
+            });
+            const res = node_mocks_http.createResponse({
+                eventEmitter: events
+            });
+            Object.assign(req, extend);
+            const proxyRes = new Proxy(res, {
+                get (obj, prop) {
+                    if ('symbol' == typeof prop && !obj[prop]) return null;
+                    return obj[prop];
+                }
+            });
+            res.on('finish', ()=>{
+                if (200 !== res.statusCode) reject(new Error(res.statusMessage));
+                else resolve(res._getData());
+            });
+            res.on('error', (e)=>reject(e));
+            try {
+                requestHandler(req, proxyRes);
+            } catch (e) {
+                reject(e);
+            }
+        });
+export { compile };

package/dist/types/libs/util.d.ts

@@ -9,7 +9,7 @@ export declare function getOutput(route: SsgRoute, base: string, agreed?: boolea
 export declare const readJSONSpec: (dir: string) => ModernRoute[];
 export declare const writeJSONSpec: (dir: string, routes: ModernRoute[]) => void;
 export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
-export declare const standardOptions: (ssgOptions: SSGConfig, entrypoints: EntryPoint[], routes: ModernRoute[], server: ServerUserConfig) => false | SSGMultiEntryOptions;
+export declare const standardOptions: (ssgOptions: SSGConfig, entrypoints: EntryPoint[], routes: ModernRoute[], server: ServerUserConfig, ssgByEntries?: SSGMultiEntryOptions) => false | SSGMultiEntryOptions;
 export declare const openRouteSSR: (routes: ModernRoute[], entries?: string[]) => {
     isSSR: boolean;
     bundle: string;

package/dist/types/server/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppNormalizedConfig, AppTools, PluginAPI } from '@modern-js/app-tools';
+import type { AppNormalizedConfig, AppToolsContext } from '@modern-js/app-tools';
 import type { ServerRoute as ModernRoute } from '@modern-js/types';
 import type { SsgRoute } from '../types';
-export declare const createServer: (api: PluginAPI<AppTools>, ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[], apiRoutes: ModernRoute[], options: AppNormalizedConfig, appDirectory: string) => Promise<string[]>;
+export declare const createServer: (appContext: AppToolsContext, ssgRoutes: SsgRoute[], pageRoutes: ModernRoute[], apiRoutes: ModernRoute[], options: AppNormalizedConfig) => Promise<string[]>;

package/package.json

@@ -15,11 +15,11 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.69.5",
+  "version": "3.0.0-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
+  "module": "./dist/esm/index.mjs",
   "typesVersions": {
     "*": {
       ".": [
@@ -33,41 +33,41 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
+      "jsnext:source": "./src/index.ts",
       "node": {
-        "jsnext:source": "./src/index.ts",
-        "import": "./dist/esm-node/index.js",
+        "import": "./dist/esm-node/index.mjs",
         "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/esm/index.js"
+      "default": "./dist/esm/index.mjs"
     },
     "./cli": {
+      "types": "./dist/types/index.d.ts",
       "jsnext:source": "./src/index.ts",
       "node": {
-        "import": "./dist/esm-node/index.js",
+        "import": "./dist/esm-node/index.mjs",
         "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/esm/index.js"
+      "default": "./dist/esm/index.mjs"
     },
     "./types": {
       "types": "./dist/types/types.d.ts",
+      "jsnext:source": "./src/types.ts",
       "node": {
-        "types": "./dist/types/types.d.ts",
-        "import": "./dist/esm-node/types.js",
+        "import": "./dist/esm-node/types.mjs",
         "require": "./dist/cjs/types.js"
       },
-      "default": "./dist/esm/types.js"
+      "default": "./dist/esm/types.mjs"
     }
   },
   "dependencies": {
     "@swc/helpers": "^0.5.17",
-    "node-mocks-http": "^1.11.0",
+    "node-mocks-http": "^1.17.2",
     "normalize-path": "3.0.0",
-    "portfinder": "^1.0.37",
-    "@modern-js/prod-server": "2.69.5",
-    "@modern-js/utils": "2.69.5"
+    "@modern-js/prod-server": "3.0.0-alpha.0",
+    "@modern-js/utils": "3.0.0-alpha.0"
   },
   "peerDependencies": {
-    "react-router-dom": ">=5.1.2"
+    "react-router-dom": ">=7.0.0"
   },
   "peerDependenciesMeta": {
     "react-router-dom": {
@@ -75,17 +75,16 @@
     }
   },
   "devDependencies": {
-    "@types/jest": "^29",
-    "@types/node": "^18",
-    "jest": "^29",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-router-dom": "6.27.0",
+    "@rslib/core": "0.18.5",
+    "@types/node": "^20",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "react-router-dom": "^7.6.0",
     "typescript": "^5",
-    "@modern-js/app-tools": "2.69.5",
-    "@modern-js/types": "2.69.5",
-    "@scripts/build": "2.66.0",
-    "@scripts/jest-config": "2.66.0"
+    "@modern-js/app-tools": "3.0.0-alpha.0",
+    "@modern-js/types": "3.0.0-alpha.0",
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/rslib": "2.68.10"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -93,9 +92,8 @@
     "access": "public"
   },
   "scripts": {
-    "new": "modern-lib new",
-    "build": "modern-lib build",
-    "dev": "modern-lib build --watch",
-    "test": "jest --passWithNoTests"
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "rstest --passWithNoTests"
   }
 }

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.ts

@@ -0,0 +1,7 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+});

package/dist/cjs/server/process.js

@@ -1,108 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var import_node_assert = __toESM(require("node:assert"));
-var import_node_http = require("node:http");
-var import_prod_server = require("@modern-js/prod-server");
-var import_utils = require("@modern-js/utils");
-var import_portfinder = __toESM(require("portfinder"));
-var import_util = require("../libs/util");
-var import_consts = require("./consts");
-function getLogger() {
-  const logger = (0, import_utils.createLogger)({
-    level: "verbose"
-  });
-  return {
-    ...logger,
-    error: (...args) => {
-      console.error(...args);
-    }
-  };
-}
-const MAX_CONCURRENT_REQUESTS = 10;
-process.on("message", async (chunk) => {
-  if (chunk === import_consts.CLOSE_SIGN) {
-    process.exit();
-  }
-  const context = JSON.parse(chunk);
-  const { routes, renderRoutes, options, appContext, plugins, distDirectory } = context;
-  let nodeServer = null;
-  try {
-    const { server: serverConfig } = options;
-    const defaultPort = Number(process.env.PORT) || serverConfig.port;
-    import_portfinder.default.basePort = defaultPort;
-    const port = await import_portfinder.default.getPortPromise();
-    const serverOptions = {
-      pwd: distDirectory,
-      config: options,
-      appContext,
-      // TODO
-      serverConfigPath: "",
-      routes,
-      plugins: await (0, import_prod_server.loadServerPlugins)(plugins, appContext.appDirectory || distDirectory),
-      staticGenerate: true,
-      logger: getLogger()
-    };
-    (0, import_node_assert.default)(process.send, "process.send is not available");
-    const sendProcessMessage = process.send.bind(process);
-    nodeServer = await (0, import_prod_server.createProdServer)(serverOptions);
-    nodeServer.listen(port, async () => {
-      if (!nodeServer)
-        return;
-      const chunkedRoutes = (0, import_util.chunkArray)(renderRoutes, MAX_CONCURRENT_REQUESTS);
-      for (const routes2 of chunkedRoutes) {
-        const promises = routes2.map(async (route) => getHtml(`http://localhost:${port}${route.urlPath}`, port));
-        for (const result of await Promise.all(promises)) {
-          sendProcessMessage(result);
-          sendProcessMessage(null);
-        }
-      }
-      nodeServer.close();
-    });
-  } catch (e) {
-    nodeServer === null || nodeServer === void 0 ? void 0 : nodeServer.close();
-    process.stderr.write(e instanceof Error ? e.stack : e.toString());
-  }
-});
-function getHtml(url, port) {
-  const headers = {
-    host: `localhost:${port}`
-  };
-  return new Promise((resolve, reject) => {
-    (0, import_node_http.request)(url, {
-      headers
-    }, (res) => {
-      const chunks = [];
-      res.on("error", (error) => {
-        reject(error);
-      });
-      res.on("data", (chunk) => {
-        chunks.push(chunk);
-      });
-      res.on("end", () => {
-        const html = Buffer.concat(chunks).toString();
-        resolve(html);
-      });
-    }).end();
-  });
-}

package/dist/esm/index.js

@@ -1,163 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import path from "path";
-import { filterRoutesForServer, logger } from "@modern-js/utils";
-import { generatePath } from "react-router-dom";
-import { makeRoute } from "./libs/make";
-import { writeHtmlFile } from "./libs/output";
-import { replaceRoute } from "./libs/replace";
-import { flattenRoutes, formatOutput, isDynamicUrl, readJSONSpec, standardOptions, writeJSONSpec } from "./libs/util";
-import { createServer } from "./server";
-var ssgPlugin = function() {
-  return {
-    name: "@modern-js/plugin-ssg",
-    pre: [
-      "@modern-js/plugin-server",
-      "@modern-js/plugin-bff"
-    ],
-    setup: function(api) {
-      var agreedRouteMap = {};
-      return {
-        modifyFileSystemRoutes: function modifyFileSystemRoutes(param) {
-          var entrypoint = param.entrypoint, routes = param.routes;
-          var entryName = entrypoint.entryName;
-          var flattedRoutes = flattenRoutes(filterRoutesForServer(routes));
-          agreedRouteMap[entryName] = flattedRoutes;
-          return {
-            entrypoint,
-            routes
-          };
-        },
-        afterBuild: function afterBuild() {
-          return _async_to_generator(function() {
-            var resolvedConfig, appContext, appDirectory, entrypoints, output, server, ssg, tmp, _ref, outputPath, ssgOptions, buildDir, routes, pageRoutes, apiRoutes, intermediateOptions, ssgRoutes, htmlAry;
-            return _ts_generator(this, function(_state) {
-              switch (_state.label) {
-                case 0:
-                  resolvedConfig = api.useResolvedConfigContext();
-                  appContext = api.useAppContext();
-                  appDirectory = appContext.appDirectory, entrypoints = appContext.entrypoints;
-                  output = resolvedConfig.output, server = resolvedConfig.server;
-                  ssg = output.ssg, tmp = output.distPath, _ref = tmp === void 0 ? {} : tmp, outputPath = _ref.root;
-                  ssgOptions = (Array.isArray(ssg) ? ssg.pop() : ssg) || true;
-                  buildDir = path.join(appDirectory, outputPath);
-                  routes = readJSONSpec(buildDir);
-                  pageRoutes = routes.filter(function(route) {
-                    return route.isSPA;
-                  });
-                  apiRoutes = routes.filter(function(route) {
-                    return !route.isSPA;
-                  });
-                  if (pageRoutes.length === 0) {
-                    return [
-                      2
-                    ];
-                  }
-                  intermediateOptions = standardOptions(ssgOptions, entrypoints, pageRoutes, server);
-                  if (!intermediateOptions) {
-                    return [
-                      2
-                    ];
-                  }
-                  ssgRoutes = [];
-                  pageRoutes.forEach(function(pageRoute) {
-                    var entryName = pageRoute.entryName, entryPath = pageRoute.entryPath;
-                    var agreedRoutes = agreedRouteMap[entryName];
-                    var entryOptions = intermediateOptions[entryName] || intermediateOptions[pageRoute.urlPath];
-                    if (!agreedRoutes) {
-                      if (!entryOptions) {
-                        return;
-                      }
-                      if (entryOptions === true) {
-                        ssgRoutes.push(_object_spread_props(_object_spread({}, pageRoute), {
-                          output: entryPath
-                        }));
-                      } else if (entryOptions.routes && entryOptions.routes.length > 0) {
-                        var enrtyRoutes = entryOptions.routes, headers = entryOptions.headers;
-                        enrtyRoutes.forEach(function(route) {
-                          ssgRoutes.push(makeRoute(pageRoute, route, headers));
-                        });
-                      }
-                    } else {
-                      if (!entryOptions) {
-                        return;
-                      }
-                      if (entryOptions === true) {
-                        entryOptions = {
-                          preventDefault: [],
-                          routes: [],
-                          headers: {}
-                        };
-                      }
-                      var _entryOptions_preventDefault = entryOptions.preventDefault, preventDefault = _entryOptions_preventDefault === void 0 ? [] : _entryOptions_preventDefault, tmp2 = entryOptions.routes, userRoutes = tmp2 === void 0 ? [] : tmp2, headers1 = entryOptions.headers;
-                      if (userRoutes.length > 0) {
-                        userRoutes.forEach(function(route) {
-                          if (typeof route === "string") {
-                            ssgRoutes.push(makeRoute(pageRoute, route, headers1));
-                          } else if (Array.isArray(route.params)) {
-                            route.params.forEach(function(param) {
-                              ssgRoutes.push(makeRoute(pageRoute, _object_spread_props(_object_spread({}, route), {
-                                url: generatePath(route.url, param)
-                              }), headers1));
-                            });
-                          } else {
-                            ssgRoutes.push(makeRoute(pageRoute, route, headers1));
-                          }
-                        });
-                      } else {
-                        agreedRoutes.filter(function(route) {
-                          return !preventDefault.includes(route.path);
-                        }).forEach(function(route) {
-                          if (!isDynamicUrl(route.path)) {
-                            ssgRoutes.push(makeRoute(pageRoute, route.path, headers1));
-                          }
-                        });
-                      }
-                    }
-                  });
-                  if (ssgRoutes.length === 0) {
-                    return [
-                      2
-                    ];
-                  }
-                  ssgRoutes.forEach(function(ssgRoute) {
-                    if (ssgRoute.isSSR) {
-                      var isOriginRoute = pageRoutes.some(function(pageRoute) {
-                        return pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName;
-                      });
-                      if (isOriginRoute) {
-                        throw new Error("ssg can not using with ssr，url - ".concat(ssgRoute.urlPath, ", entry - ").concat(ssgRoute.entryName, " "));
-                      }
-                      logger.warn("new ssg route ".concat(ssgRoute.urlPath, " is using ssr now，maybe from parent route ").concat(ssgRoute.entryName, "，close ssr"));
-                    }
-                    ssgRoute.isSSR = false;
-                    ssgRoute.output = formatOutput(ssgRoute.output);
-                  });
-                  return [
-                    4,
-                    createServer(api, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory)
-                  ];
-                case 1:
-                  htmlAry = _state.sent();
-                  writeHtmlFile(htmlAry, ssgRoutes, buildDir);
-                  replaceRoute(ssgRoutes, pageRoutes);
-                  writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
-                  logger.info("ssg Compiled successfully");
-                  return [
-                    2
-                  ];
-              }
-            });
-          })();
-        }
-      };
-    }
-  };
-};
-var src_default = ssgPlugin;
-export {
-  src_default as default,
-  ssgPlugin
-};

package/dist/esm/libs/make.js

@@ -1,36 +0,0 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
-import path from "path";
-import normalize from "normalize-path";
-function makeRender(ssgRoutes, render, port) {
-  return ssgRoutes.map(function(ssgRoute) {
-    return render({
-      url: ssgRoute.urlPath,
-      headers: _object_spread({
-        host: "localhost:".concat(port)
-      }, ssgRoute.headers),
-      connection: {}
-    });
-  });
-}
-function makeRoute(baseRoute, route) {
-  var headers = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  var urlPath = baseRoute.urlPath, entryPath = baseRoute.entryPath;
-  if (typeof route === "string") {
-    return _object_spread_props(_object_spread({}, baseRoute), {
-      urlPath: normalize("".concat(urlPath).concat(route)) || "/",
-      headers,
-      output: path.join(entryPath, "..".concat(route === "/" ? "" : route))
-    });
-  } else {
-    return _object_spread_props(_object_spread({}, baseRoute), {
-      urlPath: normalize("".concat(urlPath).concat(route.url)) || "/",
-      headers: _object_spread({}, headers, route.headers),
-      output: route.output ? path.normalize(route.output) : path.join(entryPath, "..".concat(route.url === "/" ? "" : route.url))
-    });
-  }
-}
-export {
-  makeRender,
-  makeRoute
-};

package/dist/esm/libs/output.js

@@ -1,15 +0,0 @@
-import path from "path";
-import { fs } from "@modern-js/utils";
-function writeHtmlFile(htmlAry, ssgRoutes, baseDir) {
-  htmlAry.forEach(function(html, index) {
-    var ssgRoute = ssgRoutes[index];
-    var filepath = path.join(baseDir, ssgRoute.output);
-    if (!fs.existsSync(path.dirname(filepath))) {
-      fs.ensureDirSync(path.dirname(filepath));
-    }
-    fs.writeFileSync(filepath, html);
-  });
-}
-export {
-  writeHtmlFile
-};

package/dist/esm/libs/replace.js

@@ -1,41 +0,0 @@
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import normalize from "normalize-path";
-function exist(route, pageRoutes) {
-  return pageRoutes.slice().findIndex(function(pageRoute) {
-    var urlEqual = normalize(pageRoute.urlPath) === normalize(route.urlPath);
-    var entryEqual = pageRoute.entryName === route.entryName;
-    if (urlEqual && entryEqual) {
-      return true;
-    }
-    return false;
-  });
-}
-function replaceRoute(ssgRoutes, pageRoutes) {
-  var _pageRoutes;
-  var cleanSsgRoutes = ssgRoutes.map(function(ssgRoute) {
-    var output = ssgRoute.output, headers = ssgRoute.headers, cleanSsgRoute = _object_without_properties(ssgRoute, [
-      "output",
-      "headers"
-    ]);
-    return Object.assign(cleanSsgRoute, output ? {
-      entryPath: output
-    } : {});
-  });
-  var freshRoutes = [];
-  cleanSsgRoutes.forEach(function(ssgRoute) {
-    var index = exist(ssgRoute, pageRoutes);
-    if (index < 0) {
-      freshRoutes.push(_object_spread({}, ssgRoute));
-    } else {
-      pageRoutes[index].entryPath = ssgRoute.entryPath;
-    }
-  });
-  (_pageRoutes = pageRoutes).push.apply(_pageRoutes, _to_consumable_array(freshRoutes));
-  return pageRoutes;
-}
-export {
-  exist,
-  replaceRoute
-};