@modern-js/plugin-ssg 1.2.5 → 1.2.8

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @modern-js/plugin-ssg
 
+## 1.2.8
+
+### Patch Changes
+
+- 046e58aa: fix: plugin-analyze and plugin-ssg should not import method from core
+- Updated dependencies [77ff9754]
+- Updated dependencies [d2d1d6b2]
+- Updated dependencies [07a4887e]
+- Updated dependencies [ea2ae711]
+- Updated dependencies [17d0cc46]
+- Updated dependencies [d2d1d6b2]
+  - @modern-js/utils@1.4.0
+
+## 1.2.7
+
+### Patch Changes
+
+- bebb39b6: chore: improve devDependencies and peerDependencies
+- 132f7b53: feat: move config declarations to @modern-js/core
+- Updated dependencies [132f7b53]
+  - @modern-js/utils@1.3.7
+
+## 1.2.6
+
+### Patch Changes
+
+- c7dc7f54: migrate to new plugin style
+- Updated dependencies [5bf5868d]
+  - @modern-js/utils@1.3.5
+
 ## 1.2.5
 
 ### Patch Changes

package/dist/js/modern/index.js

@@ -6,181 +6,178 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 import path from 'path';
 import { logger, PLUGIN_SCHEMAS } from '@modern-js/utils';
-import { createPlugin, useAppContext, useResolvedConfigContext } from '@modern-js/core';
 import { generatePath } from 'react-router-dom';
 import { formatOutput, isDynamicUrl, readJSONSpec, standardOptions, writeJSONSpec } from "./libs/util";
 import { createServer } from "./server";
 import { writeHtmlFile } from "./libs/output";
 import { replaceRoute } from "./libs/replace";
 import { makeRoute } from "./libs/make";
-export default createPlugin(() => {
-  const agreedRouteMap = {};
-  return {
-    validateSchema() {
-      return PLUGIN_SCHEMAS['@modern-js/plugin-ssg'];
-    },
-
-    modifyFileSystemRoutes({
-      entrypoint,
-      routes
-    }) {
-      const {
-        entryName
-      } = entrypoint;
-      agreedRouteMap[entryName] = routes;
-      return {
+export default (() => ({
+  name: '@modern-js/plugin-ssg',
+  setup: api => {
+    const agreedRouteMap = {};
+    return {
+      validateSchema() {
+        return PLUGIN_SCHEMAS['@modern-js/plugin-ssg'];
+      },
+
+      modifyFileSystemRoutes({
         entrypoint,
         routes
-      };
-    },
-
-    // eslint-disable-next-line max-statements
-    async afterBuild() {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const resolvedConfig = useResolvedConfigContext(); // eslint-disable-next-line react-hooks/rules-of-hooks
-
-      const appContext = useAppContext();
-      const {
-        appDirectory,
-        entrypoints
-      } = appContext;
-      const {
-        output
-      } = resolvedConfig;
-      const {
-        ssg,
-        path: outputPath
-      } = output;
-      const ssgOptions = Array.isArray(ssg) ? ssg.pop() : ssg; // no ssg configuration, skip ssg render.
-
-      if (!ssgOptions) {
-        return;
-      }
+      }) {
+        const {
+          entryName
+        } = entrypoint;
+        agreedRouteMap[entryName] = routes;
+        return {
+          entrypoint,
+          routes
+        };
+      },
+
+      async afterBuild() {
+        const resolvedConfig = api.useResolvedConfigContext();
+        const appContext = api.useAppContext();
+        const {
+          appDirectory,
+          entrypoints
+        } = appContext;
+        const {
+          output
+        } = resolvedConfig;
+        const {
+          ssg,
+          path: outputPath
+        } = output;
+        const ssgOptions = Array.isArray(ssg) ? ssg.pop() : ssg; // no ssg configuration, skip ssg render.
 
-      const buildDir = path.join(appDirectory, outputPath);
-      const routes = readJSONSpec(buildDir); // filter all routes not web
+        if (!ssgOptions) {
+          return;
+        }
 
-      const pageRoutes = routes.filter(route => !route.isApi);
-      const apiRoutes = routes.filter(route => route.isApi); // if no web page route, skip ssg render
+        const buildDir = path.join(appDirectory, outputPath);
+        const routes = readJSONSpec(buildDir); // filter all routes not web
 
-      if (pageRoutes.length === 0) {
-        return;
-      }
+        const pageRoutes = routes.filter(route => !route.isApi);
+        const apiRoutes = routes.filter(route => route.isApi); // if no web page route, skip ssg render
 
-      const intermediateOptions = standardOptions(ssgOptions, entrypoints);
-
-      if (!intermediateOptions) {
-        return;
-      }
+        if (pageRoutes.length === 0) {
+          return;
+        }
 
-      const ssgRoutes = []; // each route will try to match the configuration
+        const intermediateOptions = standardOptions(ssgOptions, entrypoints);
 
-      pageRoutes.forEach(pageRoute => {
-        const {
-          entryName,
-          entryPath
-        } = pageRoute;
-        const agreedRoutes = agreedRouteMap[entryName];
-        let entryOptions = intermediateOptions[entryName];
-
-        if (!agreedRoutes) {
-          // default behavior for non-agreed route
-          if (!entryOptions) {
-            return;
-          } // only add entry route if entryOptions is true
-
-
-          if (entryOptions === true) {
-            ssgRoutes.push(_objectSpread(_objectSpread({}, pageRoute), {}, {
-              output: entryPath
-            }));
-          } else if (entryOptions.routes && entryOptions.routes.length > 0) {
-            // if entryOptions is object and has routes options
-            // add every route in options
-            const {
-              routes: enrtyRoutes,
-              headers
-            } = entryOptions;
-            enrtyRoutes.forEach(route => {
-              ssgRoutes.push(makeRoute(pageRoute, route, headers));
-            });
-          }
-        } else {
-          // Unless entryOptions is set to false
-          // the default behavior is to add all file-based routes
-          if (entryOptions === false) {
-            return;
-          }
+        if (!intermediateOptions) {
+          return;
+        }
 
-          if (!entryOptions || entryOptions === true) {
-            entryOptions = {
-              preventDefault: [],
-              routes: [],
-              headers: {}
-            };
-          }
+        const ssgRoutes = []; // each route will try to match the configuration
 
+        pageRoutes.forEach(pageRoute => {
           const {
-            preventDefault = [],
-            routes: userRoutes = [],
-            headers
-          } = entryOptions; // if the user sets the routes, then only add them
-
-          if (userRoutes.length > 0) {
-            userRoutes.forEach(route => {
-              if (typeof route === 'string') {
+            entryName,
+            entryPath
+          } = pageRoute;
+          const agreedRoutes = agreedRouteMap[entryName];
+          let entryOptions = intermediateOptions[entryName];
+
+          if (!agreedRoutes) {
+            // default behavior for non-agreed route
+            if (!entryOptions) {
+              return;
+            } // only add entry route if entryOptions is true
+
+
+            if (entryOptions === true) {
+              ssgRoutes.push(_objectSpread(_objectSpread({}, pageRoute), {}, {
+                output: entryPath
+              }));
+            } else if (entryOptions.routes && entryOptions.routes.length > 0) {
+              // if entryOptions is object and has routes options
+              // add every route in options
+              const {
+                routes: enrtyRoutes,
+                headers
+              } = entryOptions;
+              enrtyRoutes.forEach(route => {
                 ssgRoutes.push(makeRoute(pageRoute, route, headers));
-              } else if (Array.isArray(route.params)) {
-                route.params.forEach(param => {
-                  ssgRoutes.push(makeRoute(pageRoute, _objectSpread(_objectSpread({}, route), {}, {
-                    url: generatePath(route.url, param)
-                  }), headers));
-                });
-              } else {
-                ssgRoutes.push(makeRoute(pageRoute, route, headers));
-              }
-            });
+              });
+            }
           } else {
-            // otherwith add all except dynamic routes
-            agreedRoutes.filter(route => !preventDefault.includes(route.path)).forEach(route => {
-              if (!isDynamicUrl(route.path)) {
-                ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
-              }
-            });
+            // Unless entryOptions is set to false
+            // the default behavior is to add all file-based routes
+            if (entryOptions === false) {
+              return;
+            }
+
+            if (!entryOptions || entryOptions === true) {
+              entryOptions = {
+                preventDefault: [],
+                routes: [],
+                headers: {}
+              };
+            }
+
+            const {
+              preventDefault = [],
+              routes: userRoutes = [],
+              headers
+            } = entryOptions; // if the user sets the routes, then only add them
+
+            if (userRoutes.length > 0) {
+              userRoutes.forEach(route => {
+                if (typeof route === 'string') {
+                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                } else if (Array.isArray(route.params)) {
+                  route.params.forEach(param => {
+                    ssgRoutes.push(makeRoute(pageRoute, _objectSpread(_objectSpread({}, route), {}, {
+                      url: generatePath(route.url, param)
+                    }), headers));
+                  });
+                } else {
+                  ssgRoutes.push(makeRoute(pageRoute, route, headers));
+                }
+              });
+            } else {
+              // otherwith add all except dynamic routes
+              agreedRoutes.filter(route => !preventDefault.includes(route.path)).forEach(route => {
+                if (!isDynamicUrl(route.path)) {
+                  ssgRoutes.push(makeRoute(pageRoute, route.path, headers));
+                }
+              });
+            }
           }
-        }
-      });
+        });
 
-      if (ssgRoutes.length === 0) {
-        return;
-      } // currently SSG and SSR cannot be turned on at the same time、same route
+        if (ssgRoutes.length === 0) {
+          return;
+        } // currently SSG and SSR cannot be turned on at the same time、same route
 
 
-      ssgRoutes.forEach(ssgRoute => {
-        if (ssgRoute.isSSR) {
-          const isOriginRoute = pageRoutes.some(pageRoute => pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName);
+        ssgRoutes.forEach(ssgRoute => {
+          if (ssgRoute.isSSR) {
+            const isOriginRoute = pageRoutes.some(pageRoute => pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName);
 
-          if (isOriginRoute) {
-            throw new Error(`ssg can not using with ssr，url - ${ssgRoute.urlPath}, entry - ${ssgRoute.entryName} `);
-          }
+            if (isOriginRoute) {
+              throw new Error(`ssg can not using with ssr，url - ${ssgRoute.urlPath}, entry - ${ssgRoute.entryName} `);
+            }
 
-          logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
-        }
+            logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
+          }
 
-        ssgRoute.isSSR = false;
-        ssgRoute.output = formatOutput(ssgRoute.output);
-      });
-      const htmlAry = await createServer(ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory); // write to dist file
+          ssgRoute.isSSR = false;
+          ssgRoute.output = formatOutput(ssgRoute.output);
+        });
+        const htmlAry = await createServer(api, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory); // write to dist file
 
-      writeHtmlFile(htmlAry, ssgRoutes, buildDir); // format route info, side effect
+        writeHtmlFile(htmlAry, ssgRoutes, buildDir); // format route info, side effect
 
-      replaceRoute(ssgRoutes, pageRoutes); // write routes to spec file
+        replaceRoute(ssgRoutes, pageRoutes); // write routes to spec file
 
-      writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
-      logger.info('ssg Compiled successfully');
-    }
+        writeJSONSpec(buildDir, pageRoutes.concat(apiRoutes));
+        logger.info('ssg Compiled successfully');
+      }
 
-  };
-}, {
-  name: '@modern-js/plugin-ssg'
-});
+    };
+  }
+}));

package/dist/js/modern/server/index.js

@@ -1,10 +1,9 @@
 import childProcess from 'child_process';
 import path from 'path';
 import { logger } from '@modern-js/utils';
-import { useAppContext } from '@modern-js/core';
 import { openRouteSSR } from "../libs/util";
 import { CLOSE_SIGN } from "./consts";
-export const createServer = (ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
+export const createServer = (api, ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
   // this side of the shallow copy of a route for subsequent render processing, to prevent the modification of the current field
   // manually enable the server-side rendering configuration for all routes that require SSG
   const backup = openRouteSSR(pageRoutes);
@@ -13,7 +12,7 @@ export const createServer = (ssgRoutes, pageRoutes, apiRoutes, options, appDirec
     cwd: appDirectory,
     silent: true
   });
-  const appContext = useAppContext();
+  const appContext = api.useAppContext();
   const serverPlugins = appContext.plugins.filter(p => p.server).map(p => p.server);
   const plugins = serverPlugins.map(p => p.name);
   cp.send(JSON.stringify({

package/dist/js/modern/types.js

@@ -1 +0,0 @@
-import '@modern-js/core';

package/dist/js/node/index.js

@@ -9,8 +9,6 @@ var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
-var _core = require("@modern-js/core");
-
 var _reactRouterDom = require("react-router-dom");
 
 var _util = require("./libs/util");
@@ -31,178 +29,176 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var _default = (0, _core.createPlugin)(() => {
-  const agreedRouteMap = {};
-  return {
-    validateSchema() {
-      return _utils.PLUGIN_SCHEMAS['@modern-js/plugin-ssg'];
-    },
-
-    modifyFileSystemRoutes({
-      entrypoint,
-      routes
-    }) {
-      const {
-        entryName
-      } = entrypoint;
-      agreedRouteMap[entryName] = routes;
-      return {
+var _default = () => ({
+  name: '@modern-js/plugin-ssg',
+  setup: api => {
+    const agreedRouteMap = {};
+    return {
+      validateSchema() {
+        return _utils.PLUGIN_SCHEMAS['@modern-js/plugin-ssg'];
+      },
+
+      modifyFileSystemRoutes({
         entrypoint,
         routes
-      };
-    },
-
-    // eslint-disable-next-line max-statements
-    async afterBuild() {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const resolvedConfig = (0, _core.useResolvedConfigContext)(); // eslint-disable-next-line react-hooks/rules-of-hooks
-
-      const appContext = (0, _core.useAppContext)();
-      const {
-        appDirectory,
-        entrypoints
-      } = appContext;
-      const {
-        output
-      } = resolvedConfig;
-      const {
-        ssg,
-        path: outputPath
-      } = output;
-      const ssgOptions = Array.isArray(ssg) ? ssg.pop() : ssg; // no ssg configuration, skip ssg render.
-
-      if (!ssgOptions) {
-        return;
-      }
-
-      const buildDir = _path.default.join(appDirectory, outputPath);
+      }) {
+        const {
+          entryName
+        } = entrypoint;
+        agreedRouteMap[entryName] = routes;
+        return {
+          entrypoint,
+          routes
+        };
+      },
+
+      async afterBuild() {
+        const resolvedConfig = api.useResolvedConfigContext();
+        const appContext = api.useAppContext();
+        const {
+          appDirectory,
+          entrypoints
+        } = appContext;
+        const {
+          output
+        } = resolvedConfig;
+        const {
+          ssg,
+          path: outputPath
+        } = output;
+        const ssgOptions = Array.isArray(ssg) ? ssg.pop() : ssg; // no ssg configuration, skip ssg render.
 
-      const routes = (0, _util.readJSONSpec)(buildDir); // filter all routes not web
+        if (!ssgOptions) {
+          return;
+        }
 
-      const pageRoutes = routes.filter(route => !route.isApi);
-      const apiRoutes = routes.filter(route => route.isApi); // if no web page route, skip ssg render
+        const buildDir = _path.default.join(appDirectory, outputPath);
 
-      if (pageRoutes.length === 0) {
-        return;
-      }
+        const routes = (0, _util.readJSONSpec)(buildDir); // filter all routes not web
 
-      const intermediateOptions = (0, _util.standardOptions)(ssgOptions, entrypoints);
+        const pageRoutes = routes.filter(route => !route.isApi);
+        const apiRoutes = routes.filter(route => route.isApi); // if no web page route, skip ssg render
 
-      if (!intermediateOptions) {
-        return;
-      }
+        if (pageRoutes.length === 0) {
+          return;
+        }
 
-      const ssgRoutes = []; // each route will try to match the configuration
+        const intermediateOptions = (0, _util.standardOptions)(ssgOptions, entrypoints);
 
-      pageRoutes.forEach(pageRoute => {
-        const {
-          entryName,
-          entryPath
-        } = pageRoute;
-        const agreedRoutes = agreedRouteMap[entryName];
-        let entryOptions = intermediateOptions[entryName];
-
-        if (!agreedRoutes) {
-          // default behavior for non-agreed route
-          if (!entryOptions) {
-            return;
-          } // only add entry route if entryOptions is true
-
-
-          if (entryOptions === true) {
-            ssgRoutes.push(_objectSpread(_objectSpread({}, pageRoute), {}, {
-              output: entryPath
-            }));
-          } else if (entryOptions.routes && entryOptions.routes.length > 0) {
-            // if entryOptions is object and has routes options
-            // add every route in options
-            const {
-              routes: enrtyRoutes,
-              headers
-            } = entryOptions;
-            enrtyRoutes.forEach(route => {
-              ssgRoutes.push((0, _make.makeRoute)(pageRoute, route, headers));
-            });
-          }
-        } else {
-          // Unless entryOptions is set to false
-          // the default behavior is to add all file-based routes
-          if (entryOptions === false) {
-            return;
-          }
+        if (!intermediateOptions) {
+          return;
+        }
 
-          if (!entryOptions || entryOptions === true) {
-            entryOptions = {
-              preventDefault: [],
-              routes: [],
-              headers: {}
-            };
-          }
+        const ssgRoutes = []; // each route will try to match the configuration
 
+        pageRoutes.forEach(pageRoute => {
           const {
-            preventDefault = [],
-            routes: userRoutes = [],
-            headers
-          } = entryOptions; // if the user sets the routes, then only add them
-
-          if (userRoutes.length > 0) {
-            userRoutes.forEach(route => {
-              if (typeof route === 'string') {
-                ssgRoutes.push((0, _make.makeRoute)(pageRoute, route, headers));
-              } else if (Array.isArray(route.params)) {
-                route.params.forEach(param => {
-                  ssgRoutes.push((0, _make.makeRoute)(pageRoute, _objectSpread(_objectSpread({}, route), {}, {
-                    url: (0, _reactRouterDom.generatePath)(route.url, param)
-                  }), headers));
-                });
-              } else {
+            entryName,
+            entryPath
+          } = pageRoute;
+          const agreedRoutes = agreedRouteMap[entryName];
+          let entryOptions = intermediateOptions[entryName];
+
+          if (!agreedRoutes) {
+            // default behavior for non-agreed route
+            if (!entryOptions) {
+              return;
+            } // only add entry route if entryOptions is true
+
+
+            if (entryOptions === true) {
+              ssgRoutes.push(_objectSpread(_objectSpread({}, pageRoute), {}, {
+                output: entryPath
+              }));
+            } else if (entryOptions.routes && entryOptions.routes.length > 0) {
+              // if entryOptions is object and has routes options
+              // add every route in options
+              const {
+                routes: enrtyRoutes,
+                headers
+              } = entryOptions;
+              enrtyRoutes.forEach(route => {
                 ssgRoutes.push((0, _make.makeRoute)(pageRoute, route, headers));
-              }
-            });
+              });
+            }
           } else {
-            // otherwith add all except dynamic routes
-            agreedRoutes.filter(route => !preventDefault.includes(route.path)).forEach(route => {
-              if (!(0, _util.isDynamicUrl)(route.path)) {
-                ssgRoutes.push((0, _make.makeRoute)(pageRoute, route.path, headers));
-              }
-            });
+            // Unless entryOptions is set to false
+            // the default behavior is to add all file-based routes
+            if (entryOptions === false) {
+              return;
+            }
+
+            if (!entryOptions || entryOptions === true) {
+              entryOptions = {
+                preventDefault: [],
+                routes: [],
+                headers: {}
+              };
+            }
+
+            const {
+              preventDefault = [],
+              routes: userRoutes = [],
+              headers
+            } = entryOptions; // if the user sets the routes, then only add them
+
+            if (userRoutes.length > 0) {
+              userRoutes.forEach(route => {
+                if (typeof route === 'string') {
+                  ssgRoutes.push((0, _make.makeRoute)(pageRoute, route, headers));
+                } else if (Array.isArray(route.params)) {
+                  route.params.forEach(param => {
+                    ssgRoutes.push((0, _make.makeRoute)(pageRoute, _objectSpread(_objectSpread({}, route), {}, {
+                      url: (0, _reactRouterDom.generatePath)(route.url, param)
+                    }), headers));
+                  });
+                } else {
+                  ssgRoutes.push((0, _make.makeRoute)(pageRoute, route, headers));
+                }
+              });
+            } else {
+              // otherwith add all except dynamic routes
+              agreedRoutes.filter(route => !preventDefault.includes(route.path)).forEach(route => {
+                if (!(0, _util.isDynamicUrl)(route.path)) {
+                  ssgRoutes.push((0, _make.makeRoute)(pageRoute, route.path, headers));
+                }
+              });
+            }
           }
-        }
-      });
+        });
 
-      if (ssgRoutes.length === 0) {
-        return;
-      } // currently SSG and SSR cannot be turned on at the same time、same route
+        if (ssgRoutes.length === 0) {
+          return;
+        } // currently SSG and SSR cannot be turned on at the same time、same route
 
 
-      ssgRoutes.forEach(ssgRoute => {
-        if (ssgRoute.isSSR) {
-          const isOriginRoute = pageRoutes.some(pageRoute => pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName);
+        ssgRoutes.forEach(ssgRoute => {
+          if (ssgRoute.isSSR) {
+            const isOriginRoute = pageRoutes.some(pageRoute => pageRoute.urlPath === ssgRoute.urlPath && pageRoute.entryName === ssgRoute.entryName);
 
-          if (isOriginRoute) {
-            throw new Error(`ssg can not using with ssr，url - ${ssgRoute.urlPath}, entry - ${ssgRoute.entryName} `);
-          }
+            if (isOriginRoute) {
+              throw new Error(`ssg can not using with ssr，url - ${ssgRoute.urlPath}, entry - ${ssgRoute.entryName} `);
+            }
 
-          _utils.logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
-        }
+            _utils.logger.warn(`new ssg route ${ssgRoute.urlPath} is using ssr now，maybe from parent route ${ssgRoute.entryName}，close ssr`);
+          }
 
-        ssgRoute.isSSR = false;
-        ssgRoute.output = (0, _util.formatOutput)(ssgRoute.output);
-      });
-      const htmlAry = await (0, _server.createServer)(ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory); // write to dist file
+          ssgRoute.isSSR = false;
+          ssgRoute.output = (0, _util.formatOutput)(ssgRoute.output);
+        });
+        const htmlAry = await (0, _server.createServer)(api, ssgRoutes, pageRoutes, apiRoutes, resolvedConfig, appDirectory); // write to dist file
 
-      (0, _output.writeHtmlFile)(htmlAry, ssgRoutes, buildDir); // format route info, side effect
+        (0, _output.writeHtmlFile)(htmlAry, ssgRoutes, buildDir); // format route info, side effect
 
-      (0, _replace.replaceRoute)(ssgRoutes, pageRoutes); // write routes to spec file
+        (0, _replace.replaceRoute)(ssgRoutes, pageRoutes); // write routes to spec file
 
-      (0, _util.writeJSONSpec)(buildDir, pageRoutes.concat(apiRoutes));
+        (0, _util.writeJSONSpec)(buildDir, pageRoutes.concat(apiRoutes));
 
-      _utils.logger.info('ssg Compiled successfully');
-    }
+        _utils.logger.info('ssg Compiled successfully');
+      }
 
-  };
-}, {
-  name: '@modern-js/plugin-ssg'
+    };
+  }
 });
 
 exports.default = _default;

package/dist/js/node/server/index.js

@@ -11,15 +11,13 @@ var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
-var _core = require("@modern-js/core");
-
 var _util = require("../libs/util");
 
 var _consts = require("./consts");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const createServer = (ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
+const createServer = (api, ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) => new Promise((resolve, reject) => {
   // this side of the shallow copy of a route for subsequent render processing, to prevent the modification of the current field
   // manually enable the server-side rendering configuration for all routes that require SSG
   const backup = (0, _util.openRouteSSR)(pageRoutes);
@@ -30,7 +28,7 @@ const createServer = (ssgRoutes, pageRoutes, apiRoutes, options, appDirectory) =
     silent: true
   });
 
-  const appContext = (0, _core.useAppContext)();
+  const appContext = api.useAppContext();
   const serverPlugins = appContext.plugins.filter(p => p.server).map(p => p.server);
   const plugins = serverPlugins.map(p => p.name);
   cp.send(JSON.stringify({

package/dist/js/node/types.js

@@ -1,3 +0,0 @@
-"use strict";
-
-require("@modern-js/core");

package/dist/types/index.d.ts

@@ -1,3 +1,5 @@
-declare const _default: any;
+import type { CliPlugin } from '@modern-js/core';
+
+declare const _default: () => CliPlugin;
 
 export default _default;

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

@@ -1,5 +1,5 @@
 import { ServerRoute as ModernRoute } from '@modern-js/types';
 import { compile } from '../server/prerender';
-import { RouteOptions, SsgRoute } from '../types';
+import { SSGRouteOptions, SsgRoute } from '../types';
 export declare function makeRender(ssgRoutes: SsgRoute[], render: ReturnType<typeof compile>, port: number): Promise<string>[];
-export declare function makeRoute(baseRoute: ModernRoute, route: string | RouteOptions, headers?: Record<string, any>): SsgRoute;
+export declare function makeRoute(baseRoute: ModernRoute, route: string | SSGRouteOptions, headers?: Record<string, any>): SsgRoute;

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

@@ -1,5 +1,5 @@
 import { ServerRoute as ModernRoute } from '@modern-js/types';
-import { EntryPoint, MultiEntryOptions, SSG, SsgRoute } from '../types';
+import { SsgRoute, SSGConfig, EntryPoint, SSGMultiEntryOptions } from '../types';
 export declare function formatOutput(filename: string): string;
 export declare function formatPath(str: string): string;
 export declare function isDynamicUrl(url: string): boolean;
@@ -8,7 +8,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: SSG, entrypoints: EntryPoint[]) => false | MultiEntryOptions;
+export declare const standardOptions: (ssgOptions: SSGConfig, entrypoints: EntryPoint[]) => false | SSGMultiEntryOptions;
 export declare const openRouteSSR: (routes: ModernRoute[]) => {
   isSSR: boolean;
   bundle: string;

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

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

package/dist/types/types.d.ts

@@ -1,5 +1,6 @@
-import { ServerRoute as ModernRoute } from '@modern-js/types';
-import '@modern-js/core';
+import type { ServerRoute as ModernRoute } from '@modern-js/types';
+import type { SSGConfig, SSGRouteOptions, SSGMultiEntryOptions, SSGSingleEntryOptions } from '@modern-js/core';
+export type { SSGConfig, SSGRouteOptions, SSGMultiEntryOptions, SSGSingleEntryOptions };
 export declare type AgreedRoute = {
   path: string;
   component: string;
@@ -17,24 +18,6 @@ export declare type SsgRoute = ModernRoute & {
   output: string;
   headers?: Record<string, string>;
 };
-export declare type RouteOptions = string | {
-  url: string;
-  output?: string;
-  params?: Record<string, any>[];
-  headers?: Record<string, any>;
-};
-export declare type SingleEntryOptions = boolean | {
-  preventDefault?: string[];
-  headers?: Record<string, any>;
-  routes?: RouteOptions[];
-};
-export declare type MultiEntryOptions = Record<string, SingleEntryOptions>;
-export declare type SSG = boolean | SingleEntryOptions | MultiEntryOptions | ((entryName: string) => SingleEntryOptions);
 export declare type ExtendOutputConfig = {
-  ssg: SSG;
-};
-declare module '@modern-js/core' {
-  interface OutputConfig {
-    ssg?: SSG;
-  }
-}
+  ssg: SSGConfig;
+};

package/jest.config.js

@@ -2,7 +2,6 @@ const sharedConfig = require('@scripts/jest-config');
 
 /** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
-  // eslint-disable-next-line node/no-unsupported-features/es-syntax
   ...sharedConfig,
   rootDir: __dirname,
 };

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.2.5",
+  "version": "1.2.8",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -55,15 +55,15 @@
   },
   "dependencies": {
     "@babel/runtime": "^7",
-    "@modern-js/utils": "^1.3.4",
+    "@modern-js/utils": "^1.4.0",
     "node-mocks-http": "^1.10.1",
     "normalize-path": "^3.0.0",
     "portfinder": "^1.0.28",
     "react-router-dom": "^5.2.1"
   },
   "devDependencies": {
-    "@modern-js/types": "^1.3.4",
-    "@modern-js/prod-server": "^1.0.2",
+    "@modern-js/types": "^1.4.0",
+    "@modern-js/prod-server": "^1.1.0",
     "@types/jest": "^26",
     "@types/node": "^14",
     "@types/react": "^17",
@@ -71,14 +71,11 @@
     "@types/react-router": "^5.1.16",
     "@types/react-router-dom": "^5.1.8",
     "typescript": "^4",
-    "@modern-js/core": "^1.4.6",
+    "@modern-js/core": "1.7.0",
     "@scripts/build": "0.0.0",
     "jest": "^27",
     "@scripts/jest-config": "0.0.0"
   },
-  "peerDependencies": {
-    "@modern-js/core": "^1.4.6"
-  },
   "sideEffects": false,
   "modernConfig": {
     "output": {

package/tests/index.test.ts

@@ -3,5 +3,6 @@ import plugin from '../src';
 describe('plugin-ssg', () => {
   it('default', () => {
     expect(plugin).toBeDefined();
+    expect(plugin().name).toBe('@modern-js/plugin-ssg');
   });
 });

package/tests/util.test.ts

@@ -74,7 +74,6 @@ describe('test ssg util function', () => {
     expect(replaceWithAlias('/src', '/src/app.js', '@src')).toBe('@src/app.js');
   });
 
-  // eslint-disable-next-line max-statements
   it('should starndar user config correctly', () => {
     const opt0 = standardOptions(false, []);
     expect(opt0).toBeFalsy();