@modern-js/plugin-ssg 1.2.5 → 1.2.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @modern-js/plugin-ssg
 
+## 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,179 @@ 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
+        };
+      },
+
+      // eslint-disable-next-line max-statements
+      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(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/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,177 @@ 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
+        };
+      },
+
+      // eslint-disable-next-line max-statements
+      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)(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/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/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.2.5",
+  "version": "1.2.6",
   "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.3.5",
     "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.3.5",
+    "@modern-js/prod-server": "^1.0.4",
     "@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.5.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');
   });
 });