@shuvi/service 1.0.63 → 2.0.0-dev.10

package/lib/bundler/bundler.d.ts

@@ -1,5 +1,5 @@
 import { RemoveListenerCallback } from '@shuvi/utils/events';
-import { Compiler as WebapckCompiler } from '@shuvi/toolpack/lib/webpack';
+import { Compiler as RspackCompiler } from '@shuvi/toolpack/lib/webpack';
 import { Server } from '../server';
 import { IPluginContext } from '../core';
 import { Target } from '../core/plugin';
@@ -24,7 +24,7 @@ export interface Bundler {
     onBuildDone(cb: FinishedCallback): RemoveListenerCallback;
     onTypeCheckingDone(cb: FinishedCallback): RemoveListenerCallback;
     applyDevMiddlewares(server: Server): void;
-    getSubCompiler(name: string): WebapckCompiler | undefined;
+    getSubCompiler(name: string): RspackCompiler | undefined;
     resolveTargetConfig(): Promise<Target[]>;
 }
 export interface CompilerStats {

package/lib/bundler/bundler.js

@@ -36,9 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBundler = getBundler;
-const path_1 = __importDefault(require("path"));
 const events_1 = require("@shuvi/utils/events");
-const forkTsCheckerWebpackPlugin_1 = __importStar(require("@shuvi/toolpack/lib/utils/forkTsCheckerWebpackPlugin"));
+const tsCheckerRspackPlugin_1 = __importStar(require("@shuvi/toolpack/lib/utils/tsCheckerRspackPlugin"));
 const formatWebpackMessages_1 = __importDefault(require("@shuvi/toolpack/lib/utils/formatWebpackMessages"));
 const logger_1 = __importDefault(require("@shuvi/utils/logger"));
 const util_1 = require("util");
@@ -56,7 +55,7 @@ const defaultBundleOptions = {
     ignoreTypeScriptErrors: false
 };
 const hasEntry = (chain) => chain.entryPoints.values().length > 0;
-class WebpackBundler {
+class RspackBundler {
     constructor(options, cliContext) {
         this._targets = [];
         this._buildEvent = (0, events_1.createEvent)();
@@ -75,19 +74,23 @@ class WebpackBundler {
             if (this._inited) {
                 return;
             }
-            let dynamicDll;
-            if (this._options.preBundle) {
-                dynamicDll = new webpack_1.DynamicDll({
-                    cacheDir: path_1.default.join(this._cliContext.paths.cacheDir, 'dll'),
-                    rootDir: this._cliContext.paths.rootDir,
-                    exclude: [/react-refresh/],
-                    resolveWebpackModule(module) {
-                        return (0, webpack_1.resolveWebpackModule)(module);
-                    }
-                });
-                this._devMiddlewares.push(dynamicDll.middleware);
-            }
-            this._compiler = yield this._getWebpackCompiler(dynamicDll);
+            /**
+             * @unsupported DynamicDll is not supported in Rspack.
+             * TODO: Implement DLL support if/when Rspack supports it.
+             */
+            // let dynamicDll: DynamicDll | undefined;
+            // if (this._options.preBundle) {
+            //   dynamicDll = new DynamicDll({
+            //     cacheDir: path.join(this._cliContext.paths.cacheDir, 'dll'),
+            //     rootDir: this._cliContext.paths.rootDir,
+            //     exclude: [/react-refresh/],
+            //     resolveWebpackModule(module) {
+            //       return resolveRspackModule(module);
+            //     }
+            //   });
+            //   this._devMiddlewares.push(dynamicDll.middleware);
+            // }
+            this._compiler = yield this._getRspackCompiler( /*dynamicDll*/);
             this._inited = true;
         });
     }
@@ -125,10 +128,23 @@ class WebpackBundler {
                 });
             }
         });
-        const webpackWatching = this._compiler.watch(this._compiler.compilers.map(childCompiler => childCompiler.options.watchOptions || {}), () => {
-            // do nothing
+        /**
+         * TODO
+         */
+        // const webpackWatching = this._compiler.watch(
+        //   this._compiler.compilers.map(
+        //     childCompiler => childCompiler.options.watchOptions || {}
+        //   ),
+        //   () => {
+        //     // do nothing
+        //   }
+        // );
+        const rspackWatching = this._compiler.watch(this._compiler.compilers[0].options.watchOptions || {}, (error, multiStats) => {
+            if (error) {
+                throw error;
+            }
         });
-        this._watching.set(webpackWatching);
+        this._watching.set(rspackWatching);
         return this._watching;
     }
     build() {
@@ -137,7 +153,7 @@ class WebpackBundler {
             if (this._options.ignoreTypeScriptErrors) {
                 logger_1.default.info('Skipping validation of types');
                 this._compiler.compilers.forEach(compiler => {
-                    forkTsCheckerWebpackPlugin_1.default.getCompilerHooks(compiler).issues.tap('afterTypeScriptCheck', (issues) => issues.filter(msg => msg.severity !== 'error'));
+                    tsCheckerRspackPlugin_1.default.getCompilerHooks(compiler).issues.tap('afterTypeScriptCheck', (issues) => issues.filter(msg => msg.severity !== 'error'));
                 });
             }
             return (0, runCompiler_1.runCompiler)(compiler);
@@ -151,21 +167,22 @@ class WebpackBundler {
     get targets() {
         return this._targets;
     }
-    _getWebpackCompiler(dynamicDll) {
+    _getRspackCompiler( /*dynamicDll?: DynamicDll | null*/) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._compiler) {
                 this._targets = yield this._getTargets();
-                if (dynamicDll) {
-                    this._compiler = (0, webpack_1.webpack)(this._targets.map(({ config }) => {
-                        if (config.target === 'node') {
-                            return config;
-                        }
-                        return dynamicDll.modifyWebpack(config);
-                    }));
-                }
-                else {
-                    this._compiler = (0, webpack_1.webpack)(this._targets.map(t => t.config));
-                }
+                // if (dynamicDll) {
+                //   this._compiler = rspack(
+                //     this._targets.map(({ config }) => {
+                //       if (config.target === 'node') {
+                //         return config;
+                //       }
+                //       return dynamicDll.modifyWebpack(config);
+                //     })
+                //   );
+                // } else {
+                this._compiler = (0, webpack_1.rspack)(this._targets.map(t => t.config));
+                // }
                 let isFirstSuccessfulCompile = true;
                 this._compiler.hooks.done.tap('done', (stats) => __awaiter(this, void 0, void 0, function* () {
                     const warnings = [];
@@ -173,6 +190,7 @@ class WebpackBundler {
                     this._isCompiling = false;
                     let timeMessage = '';
                     if (this._startTime) {
+                        // @ts-ignore exists ts error
                         const time = performance.now() - this._startTime;
                         this._startTime = 0;
                         timeMessage =
@@ -235,15 +253,15 @@ class WebpackBundler {
             tsMessagesPromise = undefined;
             isInvalid = true;
         });
-        const useTypeScript = !!((_a = compiler.options.plugins) === null || _a === void 0 ? void 0 : _a.find(plugin => plugin instanceof forkTsCheckerWebpackPlugin_1.default));
+        const useTypeScript = !!((_a = compiler.options.plugins) === null || _a === void 0 ? void 0 : _a.find(plugin => plugin instanceof tsCheckerRspackPlugin_1.default));
         if (options.typeChecking && useTypeScript) {
-            const typescriptFormatter = (0, forkTsCheckerWebpackPlugin_1.createCodeFrameFormatter)({});
+            const typescriptFormatter = (0, tsCheckerRspackPlugin_1.createCodeFrameFormatter)({});
             compiler.hooks.beforeCompile.tap('beforeCompile', () => {
                 tsMessagesPromise = new Promise(resolve => {
                     tsMessagesResolver = msgs => resolve(msgs);
                 });
             });
-            forkTsCheckerWebpackPlugin_1.default.getCompilerHooks(compiler).issues.tap('afterTypeScriptCheck', (issues) => {
+            tsCheckerRspackPlugin_1.default.getCompilerHooks(compiler).issues.tap('afterTypeScriptCheck', (issues) => {
                 const format = (message) => {
                     const file = (message.file || '').replace(/\\/g, '/');
                     const formatted = typescriptFormatter(message);
@@ -263,10 +281,11 @@ class WebpackBundler {
         }
         compiler.hooks.invalid.tap('invalid', () => {
             if (this._startTime === null) {
+                // @ts-ignore exists ts error
                 this._startTime = performance.now();
             }
         });
-        // "done" event fires when Webpack has finished recompiling the bundle.
+        // "done" event fires when Rspack has finished recompiling the bundle.
         // Whether or not you have warnings or errors, you will get this event.
         compiler.hooks.done.tap('done', (stats) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -276,7 +295,7 @@ class WebpackBundler {
                 return;
             }
             isInvalid = false;
-            // We have switched off the default Webpack output in WebpackDevServer
+            // We have switched off the default Rspack output in DevServer
             // options so we are going to "massage" the warnings and errors and present
             // them in a readable focused way.
             // We only construct the warnings and errors for speed:
@@ -359,23 +378,27 @@ class WebpackBundler {
             const extraTargets = (yield this._cliContext.pluginRunner.addExtraTarget({
                 createConfig: this._createConfig.bind(this),
                 mode: this._cliContext.mode,
-                webpack: webpack_1.webpack
+                webpack: webpack_1.rspack
             })).filter(Boolean);
             buildTargets.push(...extraTargets);
-            const defaultWebpackHelpers = { addExternals: config_1.addExternals };
+            const defaultRspackHelpers = { addExternals: config_1.addExternals };
             for (const buildTarget of buildTargets) {
                 let { chain, name } = buildTarget;
                 // modify config by api hooks
                 chain = yield this._cliContext.pluginRunner.configWebpack(chain, {
                     name,
                     mode: this._cliContext.mode,
-                    helpers: defaultWebpackHelpers,
-                    webpack: webpack_1.webpack,
+                    helpers: defaultRspackHelpers,
+                    /**
+                     * @deprecated use rspack instead
+                     */
+                    webpack: webpack_1.rspack,
+                    rspack: webpack_1.rspack,
                     resolveWebpackModule(path) {
-                        return (0, webpack_1.resolveWebpackModule)(path);
+                        return (0, webpack_1.resolveRspackModule)(path);
                     }
                 });
-                (0, config_1.checkWebpackExternals)(chain);
+                (0, config_1.checkRspackExternals)(chain);
                 if (hasEntry(chain)) {
                     const chainConfig = chain.toConfig();
                     logger_1.default.debug(`${name} Config`);
@@ -397,7 +420,7 @@ function getBundler(ctx) {
             if (ctx.mode !== 'development') {
                 options.preBundle = false;
             }
-            const bundler = new WebpackBundler(options, ctx);
+            const bundler = new RspackBundler(options, ctx);
             yield bundler.init();
             return bundler;
         }

package/lib/bundler/config.d.ts

@@ -1,4 +1,4 @@
-import { WebpackChain } from '@shuvi/toolpack/lib/webpack/config';
+import { RspackChain } from '@shuvi/toolpack/lib/webpack/config';
 import { IPluginContext } from '../core';
 export interface IWebpackEntry {
     [x: string]: string | string[];
@@ -10,4 +10,4 @@ export interface IWebpackConfigOptions {
     include?: string[];
     outputDir?: string;
 }
-export declare function createWebpackConfig({ mode, assetPublicPath, paths, config }: IPluginContext, { ...opts }: IWebpackConfigOptions): WebpackChain;
+export declare function createWebpackConfig({ mode, assetPublicPath, paths, config }: IPluginContext, { ...opts }: IWebpackConfigOptions): RspackChain;

package/lib/bundler/config.js

@@ -38,7 +38,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
     const jsConfig = (0, typescript_1.getJavaScriptInfo)();
     const compiler = Object.assign(Object.assign({}, config.compiler), { modularizeImports: experimental.modularizeImports, swcPlugins: experimental.swcPlugins, experimentalDecorators: Boolean((_b = jsConfig === null || jsConfig === void 0 ? void 0 : jsConfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.experimentalDecorators), emitDecoratorMetadata: Boolean((_c = jsConfig === null || jsConfig === void 0 ? void 0 : jsConfig.compilerOptions) === null || _c === void 0 ? void 0 : _c.emitDecoratorMetadata) });
     if (opts.node) {
-        chain = (0, config_1.createNodeWebpackChain)({
+        chain = (0, config_1.createNodeRspackChain)({
             name,
             dev,
             projectRoot,
@@ -54,7 +54,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
         });
     }
     else {
-        chain = (0, config_1.createBrowserWebpackChain)({
+        chain = (0, config_1.createBrowserRspackChain)({
             name,
             dev,
             projectRoot,

package/lib/bundler/runCompiler.d.ts

@@ -1,7 +1,7 @@
 import { Compiler, MultiCompiler } from '@shuvi/toolpack/lib/webpack';
-import type { webpack } from '@shuvi/toolpack/lib/webpack';
+import * as Rspack from '@shuvi/toolpack/lib/webpack';
 export type BundlerResult = {
-    errors: webpack.StatsError[];
-    warnings: webpack.StatsError[];
+    errors: Rspack.StatsError[];
+    warnings: Rspack.StatsError[];
 };
 export declare function runCompiler(compiler: Compiler | MultiCompiler): Promise<BundlerResult>;

package/lib/core/api.js

@@ -52,7 +52,11 @@ const plugin_1 = require("./plugin");
 const config_1 = require("./config");
 const paths_1 = require("./paths");
 const getPlugins_1 = require("./getPlugins");
-const webpack_watch_wait_for_file_builder_plugin_1 = __importDefault(require("../lib/webpack-watch-wait-for-file-builder-plugin"));
+/**
+ * @unsupported Rspack does not support WebpackWatchWaitForFileBuilderPlugin directly.
+ * TODO: Implement equivalent Rspack plugin or use Rspack's built-in watching capabilities.
+ */
+// import WebpackWatchWaitForFileBuilderPlugin from '../lib/webpack-watch-wait-for-file-builder-plugin';
 const config_2 = require("../config");
 const ServiceModes = ['development', 'production'];
 class Api {
@@ -139,24 +143,28 @@ class Api {
                     return config;
                 }
             });
-            const webpackWaitPlugin = createPlugin({
-                configWebpack: config => {
-                    if (this.mode === 'development') {
-                        config
-                            .plugin('webpack-watch-wait-for-file-builder-plugin')
-                            .use(webpack_watch_wait_for_file_builder_plugin_1.default, [
-                            {
-                                onBuildStart: this._projectBuilder.onBuildStart,
-                                onBuildEnd: this._projectBuilder.onBuildEnd,
-                                onInvalid: this._projectBuilder.onInvalid,
-                                isDependency: this._projectBuilder.isDependency
-                            }
-                        ]);
-                    }
-                    return config;
-                }
-            });
-            usePlugin(addIncludeToSwcLoader, webpackWaitPlugin);
+            /**
+             * @unsupported Rspack does not support WebpackWatchWaitForFileBuilderPlugin directly.
+             * TODO: Implement equivalent Rspack plugin or use Rspack's built-in watching capabilities.
+             */
+            // const rspackWaitPlugin = createPlugin({
+            //   configRspack: config => {
+            //     if (this.mode === 'development') {
+            //       config
+            //         .plugin('rspack-watch-wait-for-file-builder-plugin')
+            //         .use(RspackWatchWaitForFileBuilderPlugin, [
+            //           {
+            //             onBuildStart: this._projectBuilder.onBuildStart,
+            //             onBuildEnd: this._projectBuilder.onBuildEnd,
+            //             onInvalid: this._projectBuilder.onInvalid,
+            //             isDependency: this._projectBuilder.isDependency
+            //           }
+            //         ]);
+            //     }
+            //     return config;
+            //   }
+            // });
+            usePlugin(addIncludeToSwcLoader /*, rspackWaitPlugin*/);
             // 2. init user plugins
             const userPlugins = (0, getPlugins_1.getPlugins)(this._cwd, {
                 presets: this._presets,

package/lib/core/plugin.d.ts

@@ -1,6 +1,6 @@
 import { IPluginInstance, IPluginHandlers } from '@shuvi/hook';
 import { FileOptionWithId } from '../project/index';
-import { ExtraTargetAssistant, ConfigWebpackAssistant, TargetChain, BundlerDoneExtra, BundlerTargetDoneExtra, RuntimeService, Resources, AddRuntimeFileUtils, WebpackChainType } from './pluginTypes';
+import { ExtraTargetAssistant, ConfigWebpackAssistant, TargetChain, BundlerDoneExtra, BundlerTargetDoneExtra, RuntimeService, Resources, AddRuntimeFileUtils, RspackChainType } from './pluginTypes';
 import { ShuviConfig, IPluginContext, CustomCorePluginHooks } from './apiTypes';
 declare const builtinPluginHooks: {
     extendConfig: import("@shuvi/hook").SyncWaterfallHook<ShuviConfig, void>;
@@ -9,7 +9,7 @@ declare const builtinPluginHooks: {
     afterDestroy: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
     afterBundlerDone: import("@shuvi/hook").AsyncParallelHook<BundlerDoneExtra, void, void>;
     afterBundlerTargetDone: import("@shuvi/hook").AsyncParallelHook<BundlerTargetDoneExtra, void, void>;
-    configWebpack: import("@shuvi/hook").AsyncSeriesWaterfallHook<WebpackChainType, ConfigWebpackAssistant>;
+    configWebpack: import("@shuvi/hook").AsyncSeriesWaterfallHook<RspackChainType, ConfigWebpackAssistant>;
     addExtraTarget: import("@shuvi/hook").AsyncParallelHook<ExtraTargetAssistant, void, TargetChain>;
     addResource: import("@shuvi/hook").AsyncParallelHook<void, void, Resources | Resources[]>;
     addRuntimeFile: import("@shuvi/hook").AsyncParallelHook<void, AddRuntimeFileUtils, FileOptionWithId<any, any> | FileOptionWithId<any, any>[]>;

package/lib/core/pluginTypes.d.ts

@@ -1,19 +1,24 @@
 import { RequestListener } from 'http';
-import { WebpackChain } from '@shuvi/toolpack/lib/webpack';
-import { webpack, Configuration } from '@shuvi/toolpack/lib/webpack';
-import { IWebpackHelpers } from '@shuvi/toolpack/lib/webpack/types';
+import { RspackChain } from '@shuvi/toolpack/lib/webpack';
+import * as Rspack from '@shuvi/toolpack/lib/webpack';
+import { rspack, Configuration } from '@shuvi/toolpack/lib/webpack';
+import { IWebpackHelpers } from '@shuvi/toolpack/lib/webpack/types.rspack';
 import { defineFile, FileBuilder } from '../project/index';
 import { IWebpackConfigOptions } from '../bundler/config';
 import { IServiceMode } from './apiTypes';
 export type ExtraTargetAssistant = {
-    createConfig(options: IWebpackConfigOptions): WebpackChain;
+    createConfig(options: IWebpackConfigOptions): RspackChain;
     mode: IServiceMode;
-    webpack: typeof webpack;
+    webpack: typeof rspack;
 };
 export type ConfigWebpackAssistant = {
     name: string;
     mode: IServiceMode;
-    webpack: typeof webpack;
+    /**
+     * @deprecated use rspack instead
+     */
+    webpack: typeof rspack;
+    rspack: typeof rspack;
     /**
      * require webpack interal module
      * eg. resolveWebpackModule('webpack/lib/dependencies/ConstDependency')
@@ -23,7 +28,7 @@ export type ConfigWebpackAssistant = {
 };
 export interface TargetChain {
     name: string;
-    chain: WebpackChain;
+    chain: RspackChain;
 }
 export interface Target {
     name: string;
@@ -31,12 +36,12 @@ export interface Target {
 }
 export type BundlerDoneExtra = {
     first: boolean;
-    stats: webpack.MultiStats;
+    stats: Rspack.MultiStats;
 };
 export type BundlerTargetDoneExtra = {
     first: boolean;
     name: string;
-    stats: webpack.Stats;
+    stats: Rspack.Stats;
 };
 export type RuntimeService = {
     source: string;
@@ -48,7 +53,7 @@ export type AddRuntimeFileUtils = {
     defineFile: typeof defineFile;
     getContent: FileBuilder<any>['getContent'];
 };
-export interface WebpackChainType extends WebpackChain {
+export interface RspackChainType extends RspackChain {
 }
 export type AfterBuildOptions = {
     requestHandler: RequestListener;

package/lib/server/shuviDevServer.js

@@ -171,24 +171,39 @@ class ShuviDevServer extends shuviServer_1.ShuviServer {
                         (0, env_1.loadDotenvConfig)({ rootDir, forceReloadEnv: true });
                     }
                     configs.forEach(({ config }) => {
-                        var _a, _b, _c;
+                        var _a;
                         if (tsconfigChange) {
-                            (_b = (_a = config.resolve) === null || _a === void 0 ? void 0 : _a.plugins) === null || _b === void 0 ? void 0 : _b.forEach((plugin) => {
-                                // look for the JsConfigPathsPlugin and update with the latest paths/baseUrl config
-                                if (plugin && plugin.jsConfigPlugin && parseJsConfig) {
-                                    const { resolvedBaseUrl, compilerOptions } = parseJsConfig;
-                                    if (compilerOptions.paths && resolvedBaseUrl) {
-                                        Object.keys(plugin.paths).forEach(key => {
-                                            delete plugin.paths[key];
-                                        });
-                                        plugin.paths = Object.assign({}, compilerOptions.paths);
-                                        plugin.resolvedBaseUrl = resolvedBaseUrl;
-                                    }
-                                }
-                            });
+                            /**
+                             * @unsupported Rspack does not support resolve.plugins array like webpack.
+                             * TODO: Handle this after Rspack support is available.
+                             * For now, we'll use Rspack's built-in tsConfig support instead.
+                             */
+                            // config.resolve?.plugins?.forEach((plugin: any) => {
+                            //   // look for the JsConfigPathsPlugin and update with the latest paths/baseUrl config
+                            //   if (plugin && plugin.jsConfigPlugin && parseJsConfig) {
+                            //     const { resolvedBaseUrl, compilerOptions } = parseJsConfig;
+                            //     if (compilerOptions.paths && resolvedBaseUrl) {
+                            //       Object.keys(plugin.paths).forEach(key => {
+                            //         delete plugin.paths[key];
+                            //       });
+                            //       plugin.paths = { ...compilerOptions.paths };
+                            //       plugin.resolvedBaseUrl = resolvedBaseUrl;
+                            //     }
+                            //   }
+                            // });
+                            // Use Rspack's built-in tsConfig support
+                            if (parseJsConfig && config.resolve) {
+                                /**
+                                 * @TODO
+                                 * @unsupported Rspack's tsConfig type is not fully compatible with ParsedJsConfig.
+                                 * TODO: Update when Rspack provides proper TypeScript configuration support.
+                                 */
+                                // @ts-expect-error wrong!!
+                                config.resolve.tsConfig = parseJsConfig;
+                            }
                         }
                         if (envChange) {
-                            (_c = config.plugins) === null || _c === void 0 ? void 0 : _c.forEach((plugin) => {
+                            (_a = config.plugins) === null || _a === void 0 ? void 0 : _a.forEach((plugin) => {
                                 // we look for the DefinePlugin definitions so we can
                                 // update them on the active compilers
                                 if (plugin &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/service",
-  "version": "1.0.63",
+  "version": "2.0.0-dev.10",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",
@@ -29,14 +29,14 @@
     "@babel/generator": "7.14.5",
     "@babel/parser": "7.14.7",
     "@babel/traverse": "7.14.7",
-    "@shuvi/hook": "1.0.63",
-    "@shuvi/router": "1.0.63",
-    "@shuvi/runtime": "1.0.63",
-    "@shuvi/shared": "1.0.63",
-    "@shuvi/toolpack": "1.0.63",
-    "@shuvi/utils": "1.0.63",
-    "@shuvi/error-overlay": "1.0.63",
-    "@shuvi/reporters": "1.0.63",
+    "@shuvi/hook": "2.0.0-dev.10",
+    "@shuvi/router": "2.0.0-dev.10",
+    "@shuvi/runtime": "2.0.0-dev.10",
+    "@shuvi/shared": "2.0.0-dev.10",
+    "@shuvi/toolpack": "2.0.0-dev.10",
+    "@shuvi/utils": "2.0.0-dev.10",
+    "@shuvi/error-overlay": "2.0.0-dev.10",
+    "@shuvi/reporters": "2.0.0-dev.10",
     "commander": "5.1.0",
     "comment-json": "4.2.2",
     "cross-spawn": "7.0.3",