@modern-js/app-tools 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/js/treeshaking/config/default.js

@@ -0,0 +1,200 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export function createDefaultConfig(appContext) {
+  var _ref;
+  var defaultAlias = appContext ? (_ref = {}, _defineProperty(_ref, appContext.internalDirAlias, appContext.internalDirectory), _defineProperty(_ref, appContext.internalSrcAlias, appContext.srcDirectory), _defineProperty(_ref, '@', appContext.srcDirectory), _defineProperty(_ref, '@shared', appContext.sharedDirectory), _ref) : {};
+  var source = {
+    entries: undefined,
+    enableAsyncEntry: false,
+    disableDefaultEntries: false,
+    entriesDir: './src',
+    configDir: './config',
+    globalVars: undefined,
+    moduleScopes: undefined,
+    include: [],
+    alias: defaultAlias
+  };
+  var output = {
+    assetPrefix: '/',
+    distPath: {
+      html: 'html',
+      js: 'static/js',
+      css: 'static/css',
+      media: 'static/media',
+      root: 'dist'
+    },
+    copy: undefined,
+    disableCssModuleExtension: false,
+    enableCssModuleTSDeclaration: false,
+    disableMinimize: false,
+    enableInlineStyles: false,
+    enableInlineScripts: false,
+    disableSourceMap: false,
+    disableInlineRuntimeChunk: false,
+    disableFilenameHash: false,
+    enableLatestDecorators: false,
+    polyfill: 'entry',
+    dataUriLimit: 10000,
+    cssModuleLocalIdentName: undefined
+  };
+  var html = {
+    title: '',
+    titleByEntries: undefined,
+    meta: {
+      charset: {
+        charset: 'utf-8'
+      },
+      viewport: 'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
+      'http-equiv': {
+        'http-equiv': 'x-ua-compatible',
+        content: 'ie=edge'
+      },
+      renderer: 'webkit',
+      layoutmode: 'standard',
+      imagemode: 'force',
+      'wap-font-scale': 'no',
+      'format-detection': 'telephone=no'
+    },
+    metaByEntries: undefined,
+    inject: 'head',
+    injectByEntries: undefined,
+    mountId: 'root',
+    favicon: '',
+    faviconByEntries: undefined,
+    disableHtmlFolder: false,
+    templateParameters: {},
+    templateParametersByEntries: undefined
+  };
+  var server = {
+    routes: undefined,
+    publicRoutes: undefined,
+    ssr: undefined,
+    ssrByEntries: undefined,
+    baseUrl: '/',
+    port: 8080
+  };
+  var dev = {
+    assetPrefix: false,
+    https: false
+  };
+  var tools = {
+    webpack: undefined,
+    babel: undefined,
+    postcss: undefined,
+    autoprefixer: undefined,
+    devServer: undefined,
+    tsLoader: undefined,
+    terser: undefined,
+    minifyCss: undefined
+  };
+  return {
+    source: source,
+    output: output,
+    server: server,
+    dev: dev,
+    html: html,
+    tools: tools,
+    plugins: [],
+    runtime: {},
+    runtimeByEntries: {}
+  };
+}
+export function createLegacyDefaultConfig(appContext) {
+  var _ref2;
+  var defaultAlias = appContext ? (_ref2 = {}, _defineProperty(_ref2, appContext.internalDirAlias, appContext.internalDirectory), _defineProperty(_ref2, appContext.internalSrcAlias, appContext.srcDirectory), _defineProperty(_ref2, '@', appContext.srcDirectory), _defineProperty(_ref2, '@shared', appContext.sharedDirectory), _ref2) : {};
+  var sourceDefaults = {
+    entries: undefined,
+    enableAsyncEntry: false,
+    disableDefaultEntries: false,
+    entriesDir: './src',
+    configDir: './config',
+    apiDir: './api',
+    envVars: [],
+    globalVars: undefined,
+    alias: defaultAlias,
+    moduleScopes: undefined,
+    include: []
+  };
+  var outputDefaults = {
+    assetPrefix: '/',
+    htmlPath: 'html',
+    jsPath: 'static/js',
+    cssPath: 'static/css',
+    mediaPath: 'static/media',
+    path: 'dist',
+    title: '',
+    titleByEntries: undefined,
+    meta: {
+      charset: {
+        charset: 'utf-8'
+      },
+      viewport: 'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
+      'http-equiv': {
+        'http-equiv': 'x-ua-compatible',
+        content: 'ie=edge'
+      },
+      renderer: 'webkit',
+      layoutmode: 'standard',
+      imagemode: 'force',
+      'wap-font-scale': 'no',
+      'format-detection': 'telephone=no'
+    },
+    metaByEntries: undefined,
+    inject: 'head',
+    injectByEntries: undefined,
+    mountId: 'root',
+    favicon: '',
+    faviconByEntries: undefined,
+    copy: undefined,
+    disableHtmlFolder: false,
+    disableCssModuleExtension: false,
+    disableCssExtract: false,
+    enableCssModuleTSDeclaration: false,
+    disableMinimize: false,
+    enableInlineStyles: false,
+    enableInlineScripts: false,
+    disableSourceMap: false,
+    disableInlineRuntimeChunk: false,
+    disableAssetsCache: false,
+    enableLatestDecorators: false,
+    polyfill: 'entry',
+    dataUriLimit: 10000,
+    templateParameters: {},
+    templateParametersByEntries: undefined,
+    cssModuleLocalIdentName: undefined,
+    enableModernMode: false,
+    disableNodePolyfill: false,
+    enableTsLoader: false
+  };
+  var serverDefaults = {
+    routes: undefined,
+    publicRoutes: undefined,
+    ssr: undefined,
+    ssrByEntries: undefined,
+    baseUrl: '/',
+    port: 8080
+  };
+  var devDefaults = {
+    assetPrefix: false,
+    https: false
+  };
+  var toolsDefaults = {
+    webpack: undefined,
+    babel: undefined,
+    postcss: undefined,
+    autoprefixer: undefined,
+    lodash: undefined,
+    devServer: undefined,
+    tsLoader: undefined,
+    terser: undefined,
+    minifyCss: undefined
+  };
+  return {
+    source: sourceDefaults,
+    output: outputDefaults,
+    server: serverDefaults,
+    dev: devDefaults,
+    tools: toolsDefaults,
+    runtime: {},
+    runtimeByEntries: {}
+  };
+}

package/dist/js/treeshaking/config/index.js

@@ -0,0 +1,2 @@
+export { createDefaultConfig, createLegacyDefaultConfig } from "./default";
+export { initialNormalizedConfig, checkIsLegacyConfig } from "./initial";

package/dist/js/treeshaking/config/initial/createHtmlConfig.js

@@ -0,0 +1,31 @@
+export function createHtmlConfig(config) {
+  var _config$output = config.output,
+    disableHtmlFolder = _config$output.disableHtmlFolder,
+    favicon = _config$output.favicon,
+    faviconByEntries = _config$output.faviconByEntries,
+    inject = _config$output.inject,
+    injectByEntries = _config$output.injectByEntries,
+    meta = _config$output.meta,
+    metaByEntries = _config$output.metaByEntries,
+    mountId = _config$output.mountId,
+    title = _config$output.title,
+    titleByEntries = _config$output.titleByEntries,
+    templateParameters = _config$output.templateParameters,
+    templateParametersByEntries = _config$output.templateParametersByEntries,
+    crossorigin = _config$output.crossorigin;
+  return {
+    disableHtmlFolder: disableHtmlFolder,
+    favicon: favicon,
+    faviconByEntries: faviconByEntries,
+    inject: inject,
+    injectByEntries: injectByEntries,
+    meta: meta,
+    metaByEntries: metaByEntries,
+    mountId: mountId,
+    title: title,
+    titleByEntries: titleByEntries,
+    crossorigin: crossorigin,
+    templateParameters: templateParameters,
+    templateParametersByEntries: templateParametersByEntries
+  };
+}

package/dist/js/treeshaking/config/initial/createOutputConfig.js

@@ -0,0 +1,67 @@
+export function createOutputConfig(config) {
+  var _config$output = config.output,
+    assetPrefix = _config$output.assetPrefix,
+    copy = _config$output.copy,
+    cssModuleLocalIdentName = _config$output.cssModuleLocalIdentName,
+    cssPath = _config$output.cssPath,
+    jsPath = _config$output.jsPath,
+    htmlPath = _config$output.htmlPath,
+    mediaPath = _config$output.mediaPath,
+    enableTsLoader = _config$output.enableTsLoader,
+    path = _config$output.path,
+    disableInlineRuntimeChunk = _config$output.disableInlineRuntimeChunk,
+    disableCssExtract = _config$output.disableCssExtract,
+    disableMinimize = _config$output.disableMinimize,
+    disableSourceMap = _config$output.disableSourceMap,
+    disableTsChecker = _config$output.disableTsChecker,
+    enableCssModuleTSDeclaration = _config$output.enableCssModuleTSDeclaration,
+    enableInlineScripts = _config$output.enableInlineScripts,
+    enableInlineStyles = _config$output.enableInlineStyles,
+    polyfill = _config$output.polyfill,
+    dataUriLimit = _config$output.dataUriLimit,
+    disableAssetsCache = _config$output.disableAssetsCache,
+    enableLatestDecorators = _config$output.enableLatestDecorators,
+    disableCssModuleExtension = _config$output.disableCssModuleExtension,
+    ssg = _config$output.ssg,
+    enableModernMode = _config$output.enableModernMode,
+    disableNodePolyfill = _config$output.disableNodePolyfill;
+  return {
+    assetPrefix: assetPrefix,
+    copy: copy,
+    distPath: {
+      root: path,
+      css: cssPath,
+      js: jsPath,
+      html: htmlPath,
+      // `@modern-js/webpack` output all media files to `dist/media` by default
+      svg: mediaPath || 'media',
+      image: mediaPath || 'media',
+      font: mediaPath || 'media',
+      media: mediaPath || 'media'
+    },
+    dataUriLimit: {
+      svg: dataUriLimit,
+      image: dataUriLimit,
+      font: dataUriLimit,
+      media: dataUriLimit
+    },
+    disableCssExtract: disableCssExtract,
+    disableCssModuleExtension: disableCssModuleExtension,
+    disableInlineRuntimeChunk: disableInlineRuntimeChunk,
+    disableMinimize: disableMinimize,
+    disableSourceMap: disableSourceMap,
+    disableTsChecker: disableTsChecker || enableTsLoader,
+    enableCssModuleTSDeclaration: enableCssModuleTSDeclaration,
+    enableInlineScripts: enableInlineScripts,
+    enableInlineStyles: enableInlineStyles,
+    polyfill: polyfill,
+    disableFilenameHash: disableAssetsCache,
+    enableLatestDecorators: enableLatestDecorators,
+    filename: {
+      css: cssModuleLocalIdentName
+    },
+    ssg: ssg,
+    enableModernMode: enableModernMode,
+    disableNodePolyfill: disableNodePolyfill
+  };
+}

package/dist/js/treeshaking/config/initial/createSourceConfig.js

@@ -0,0 +1,41 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function createSourceConfig(config) {
+  var _config$source = config.source,
+    alias = _config$source.alias,
+    envVars = _config$source.envVars,
+    globalVars = _config$source.globalVars,
+    include = _config$source.include,
+    moduleScopes = _config$source.moduleScopes,
+    preEntry = _config$source.preEntry,
+    entries = _config$source.entries,
+    enableAsyncEntry = _config$source.enableAsyncEntry,
+    disableDefaultEntries = _config$source.disableDefaultEntries,
+    entriesDir = _config$source.entriesDir,
+    configDir = _config$source.configDir;
+  var builderGlobalVars = globalVars || {};
+  var _iterator = _createForOfIteratorHelper(envVars || []),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var envVar = _step.value;
+      var envVarValue = process.env[envVar];
+      envVarValue && (builderGlobalVars["process.env.".concat(envVar)] = envVarValue);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    alias: alias,
+    moduleScopes: moduleScopes,
+    globalVars: builderGlobalVars,
+    include: include,
+    preEntry: preEntry,
+    entries: entries,
+    enableAsyncEntry: enableAsyncEntry,
+    disableDefaultEntries: disableDefaultEntries,
+    entriesDir: entriesDir,
+    configDir: configDir
+  };
+}

package/dist/js/treeshaking/config/initial/createToolsConfig.js

@@ -0,0 +1,38 @@
+export function createToolsConfig(config) {
+  var _config$tools = config.tools,
+    autoprefixer = _config$tools.autoprefixer,
+    babel = _config$tools.babel,
+    minifyCss = _config$tools.minifyCss,
+    terser = _config$tools.terser,
+    webpack = _config$tools.webpack,
+    webpackChain = _config$tools.webpackChain,
+    tsLoader = _config$tools.tsLoader,
+    styledComponents = _config$tools.styledComponents,
+    sass = _config$tools.sass,
+    postcss = _config$tools.postcss,
+    less = _config$tools.less,
+    htmlPlugin = _config$tools.htmlPlugin,
+    devServer = _config$tools.devServer,
+    tailwindcss = _config$tools.tailwindcss,
+    jest = _config$tools.jest,
+    esbuild = _config$tools.esbuild;
+  var enableTsLoader = config.output.enableTsLoader;
+  return {
+    tsLoader: enableTsLoader ? tsLoader : undefined,
+    autoprefixer: autoprefixer,
+    babel: babel,
+    minifyCss: minifyCss,
+    terser: terser,
+    webpack: webpack,
+    webpackChain: webpackChain,
+    styledComponents: styledComponents,
+    sass: sass,
+    postcss: postcss,
+    less: less,
+    htmlPlugin: htmlPlugin,
+    devServer: devServer,
+    tailwindcss: tailwindcss,
+    jest: jest,
+    esbuild: esbuild
+  };
+}

package/dist/js/treeshaking/config/initial/index.js

@@ -0,0 +1,11 @@
+import { initHtmlConfig, initSourceConfig, initToolsConfig } from "./inits";
+export { transformNormalizedConfig } from "./transformNormalizedConfig";
+export function checkIsLegacyConfig(config) {
+  return Boolean(config.legacy);
+}
+export function initialNormalizedConfig(config, appContext) {
+  initHtmlConfig(config, appContext);
+  initSourceConfig(config, appContext);
+  initToolsConfig(config);
+  return config;
+}

package/dist/js/treeshaking/config/initial/inits.js

@@ -0,0 +1,114 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import path, { dirname, isAbsolute, posix, sep } from 'path';
+import { applyOptionsChain, findExists, findMonorepoRoot, globby, isModernjsMonorepo } from '@modern-js/utils';
+export function initHtmlConfig(config, appContext) {
+  var ICON_EXTENSIONS = ['png', 'jpg', 'jpeg', 'svg', 'ico'];
+  config.html.appIcon = createBuilderAppIcon(config, appContext);
+  config.html.favicon = createBuilderFavicon(config, appContext);
+  return config.html;
+  function createBuilderAppIcon(config, appContext) {
+    var configDir = config.source.configDir;
+    var appIcon = findExists(ICON_EXTENSIONS.map(function (ext) {
+      return path.resolve(appContext.appDirectory, configDir || './config', "icon.".concat(ext));
+    }));
+    return typeof appIcon === 'string' ? appIcon : undefined;
+  }
+  function createBuilderFavicon(config, appContext) {
+    var configDir = config.source.configDir;
+    var favicon = config.html.favicon;
+    var defaultFavicon = findExists(ICON_EXTENSIONS.map(function (ext) {
+      return path.resolve(appContext.appDirectory, configDir || './config', "favicon.".concat(ext));
+    }));
+    return favicon || defaultFavicon || undefined;
+  }
+}
+export function initSourceConfig(config, appContext) {
+  config.source.include = createBuilderInclude(config, appContext);
+  config.source.moduleScopes = createBuilderModuleScope(config);
+  function createBuilderInclude(config, appContext) {
+    var include = config.source.include;
+    var defaultInclude = [appContext.internalDirectory];
+    var transformInclude = (include || []).map(function (include) {
+      if (typeof include === 'string') {
+        if (isAbsolute(include)) {
+          return include;
+        }
+        return new RegExp(include);
+      }
+      return include;
+    }).concat(defaultInclude); // concat default Include
+
+    var root = findMonorepoRoot(appContext.appDirectory);
+    if (!root) {
+      return transformInclude;
+    }
+    var modernjsMonorepo = isModernjsMonorepo(root);
+    if (modernjsMonorepo) {
+      var paths = globby.sync(posix.join(root, 'features', '**', 'package.json'), {
+        ignore: ['**/node_modules/**/*']
+      }).map(function (pathname) {
+        return dirname(pathname) + sep;
+      });
+      return [].concat(_toConsumableArray(paths), _toConsumableArray(transformInclude));
+    }
+    return transformInclude;
+  }
+  function createBuilderModuleScope(config) {
+    var moduleScopes = config.source.moduleScopes;
+    if (moduleScopes) {
+      var builderModuleScope = [];
+      var DEFAULT_SCOPES = ['./src', './shared', /node_modules/];
+      if (Array.isArray(moduleScopes)) {
+        if (isPrimitiveScope(moduleScopes)) {
+          builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
+        } else {
+          builderModuleScope = [DEFAULT_SCOPES].concat(_toConsumableArray(moduleScopes));
+        }
+      } else {
+        builderModuleScope = [DEFAULT_SCOPES, moduleScopes];
+      }
+      return builderModuleScope;
+    } else {
+      return undefined;
+    }
+    function isPrimitiveScope(items) {
+      return items.every(function (item) {
+        return typeof item === 'string' || Object.prototype.toString.call(item) === '[object RegExp]';
+      });
+    }
+  }
+}
+export function initToolsConfig(config) {
+  var defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  var _config$tools = config.tools,
+    tsChecker = _config$tools.tsChecker,
+    tsLoader = _config$tools.tsLoader,
+    htmlPlugin = _config$tools.htmlPlugin;
+  config.tools.tsChecker = applyOptionsChain(defaultTsChecker, tsChecker);
+  tsLoader && (config.tools.tsLoader = function (tsLoaderConfig, utils) {
+    applyOptionsChain(_objectSpread(_objectSpread({}, tsLoaderConfig), {}, {
+      transpileOnly: false,
+      allowTsInNodeModules: true
+    }), tsLoader || {}, utils);
+  });
+  config.tools.htmlPlugin = [function (config) {
+    return _objectSpread(_objectSpread({}, config), {}, {
+      minify: _typeof(config.minify) === 'object' ? _objectSpread(_objectSpread({}, config.minify), {}, {
+        removeComments: false
+      }) : config.minify
+    });
+  }].concat(_toConsumableArray(Array.isArray(htmlPlugin) ? htmlPlugin : htmlPlugin ? [htmlPlugin] : []));
+}

package/dist/js/treeshaking/config/initial/transformNormalizedConfig.js

@@ -0,0 +1,38 @@
+import { createToolsConfig } from "./createToolsConfig";
+import { createSourceConfig } from "./createSourceConfig";
+import { createOutputConfig } from "./createOutputConfig";
+import { createHtmlConfig } from "./createHtmlConfig";
+export function transformNormalizedConfig(config) {
+  var html = createHtmlConfig(config);
+  var output = createOutputConfig(config);
+  var source = createSourceConfig(config);
+  var tools = createToolsConfig(config);
+  var bff = config.bff,
+    dev = config.dev,
+    deploy = config.deploy,
+    runtime = config.runtime,
+    runtimeByEntries = config.runtimeByEntries,
+    server = config.server,
+    cliOptions = config.cliOptions,
+    plugins = config.plugins,
+    testing = config.testing;
+  return {
+    source: source,
+    html: html,
+    output: output,
+    tools: tools,
+    bff: bff,
+    dev: dev,
+    deploy: deploy,
+    runtime: runtime,
+    runtimeByEntries: runtimeByEntries,
+    server: server,
+    cliOptions: cliOptions,
+    testing: testing,
+    plugins: plugins,
+    security: {},
+    _raw: {},
+    experiments: {},
+    performance: {}
+  };
+}

package/dist/js/treeshaking/defineConfig.js

@@ -0,0 +1,14 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var defineConfig = function defineConfig(config) {
+  return config;
+};
+
+/**
+ * @deprecated
+ * Using defineConfig first.
+ */
+export var defineLegacyConfig = function defineLegacyConfig(config) {
+  return _objectSpread(_objectSpread({}, config), {}, {
+    legacy: true
+  });
+};

package/dist/js/treeshaking/hooks.js

@@ -1,21 +1,25 @@
-import { createAsyncWaterfall, createAsyncWorkflow } from '@modern-js/plugin';
-export var beforeDev = createAsyncWorkflow();
-export var afterDev = createAsyncWorkflow();
-export var beforeCreateCompiler = createAsyncWorkflow();
-export var afterCreateCompiler = createAsyncWorkflow();
-export var beforePrintInstructions = createAsyncWaterfall();
-export var beforeBuild = createAsyncWorkflow();
-export var afterBuild = createAsyncWorkflow();
-export var beforeDeploy = createAsyncWorkflow();
-export var afterDeploy = createAsyncWorkflow();
+import { createAsyncWaterfall, createAsyncWorkflow, createParallelWorkflow } from '@modern-js/plugin';
 export var hooks = {
-  beforeDev: beforeDev,
-  afterDev: afterDev,
-  beforeCreateCompiler: beforeCreateCompiler,
-  afterCreateCompiler: afterCreateCompiler,
-  beforePrintInstructions: beforePrintInstructions,
-  beforeBuild: beforeBuild,
-  afterBuild: afterBuild,
-  beforeDeploy: beforeDeploy,
-  afterDeploy: afterDeploy
+  modifyEntryExport: createAsyncWaterfall(),
+  modifyEntryImports: createAsyncWaterfall(),
+  modifyEntryRuntimePlugins: createAsyncWaterfall(),
+  modifyEntryRenderFunction: createAsyncWaterfall(),
+  modifyAsyncEntry: createAsyncWaterfall(),
+  modifyFileSystemRoutes: createAsyncWaterfall(),
+  modifyServerRoutes: createAsyncWaterfall(),
+  htmlPartials: createAsyncWaterfall(),
+  beforeGenerateRoutes: createAsyncWaterfall(),
+  addDefineTypes: createAsyncWaterfall(),
+  beforeDev: createAsyncWorkflow(),
+  afterDev: createAsyncWorkflow(),
+  beforeCreateCompiler: createAsyncWorkflow(),
+  afterCreateCompiler: createAsyncWorkflow(),
+  beforePrintInstructions: createAsyncWaterfall(),
+  beforeBuild: createAsyncWorkflow(),
+  afterBuild: createAsyncWorkflow(),
+  beforeDeploy: createAsyncWorkflow(),
+  afterDeploy: createAsyncWorkflow(),
+  watchFiles: createParallelWorkflow(),
+  fileChange: createAsyncWorkflow(),
+  beforeRestart: createAsyncWorkflow()
 };

package/dist/js/treeshaking/index.js

@@ -2,22 +2,24 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import path from 'path';
-import { defineConfig, cli } from '@modern-js/core';
 import LintPlugin from '@modern-js/plugin-lint';
 import { cleanRequireCache, emptyDir, Import } from '@modern-js/utils';
 import AnalyzePlugin from "./analyze";
+import InitializePlugin from "./initialize";
 import { hooks } from "./hooks";
 import { i18n, localeKeys } from "./locale";
 import { getLocaleLanguage } from "./utils/language";
 import { getCommand } from "./utils/commands";
-export { defineConfig, hooks };
+import { restart } from "./utils/restart";
+export * from "./defineConfig";
+export * from "./types";
 var upgradeModel = Import.lazy('@modern-js/upgrade', require);
 export default (function () {
   return {
     name: '@modern-js/app-tools',
-    post: ['@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-document', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-router-legacy', '@modern-js/plugin-polyfill'],
+    post: ['@modern-js/plugin-initialize', '@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-document', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-router-legacy', '@modern-js/plugin-polyfill'],
     registerHook: hooks,
-    usePlugins: [AnalyzePlugin(), LintPlugin()],
+    usePlugins: [InitializePlugin(), AnalyzePlugin(), LintPlugin()],
     setup: function setup(api) {
       var locale = getLocaleLanguage();
       i18n.changeLanguage({
@@ -237,7 +239,7 @@ export default (function () {
                     return closeServer();
                   case 11:
                     _context8.next = 13;
-                    return cli.restart();
+                    return restart(api.useHookRunners());
                   case 13:
                   case "end":
                     return _context8.stop();