@modern-js/app-tools 1.21.2 → 2.0.0-beta.0

package/dist/js/node/builder/createSourceConfig.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderInclude = createBuilderInclude;
+exports.createBuilderModuleScope = createBuilderModuleScope;
+exports.createSourceConfig = createSourceConfig;
+
+var _path = require("path");
+
+var _utils = require("@modern-js/utils");
+
+function createSourceConfig(normalizedConfig, appContext) {
+  const {
+    alias,
+    envVars,
+    globalVars,
+    include,
+    moduleScopes,
+    preEntry
+  } = normalizedConfig.source;
+  const builderGlobalVars = globalVars || {};
+
+  for (const envVar of envVars || []) {
+    const envVarValue = process.env[envVar];
+    envVarValue && (builderGlobalVars[`process.env.${envVar}`] = envVarValue);
+  }
+
+  const builderModuleScope = createBuilderModuleScope(moduleScopes);
+  const builderInclude = createBuilderInclude(include, appContext);
+  return {
+    alias: (0, _utils.mergeAlias)(alias),
+    moduleScopes: builderModuleScope,
+    globalVars: builderGlobalVars,
+    include: builderInclude,
+    preEntry,
+    // ensure resolve.extensions same as before
+    resolveExtensionPrefix: '.web'
+  };
+}
+
+function createBuilderInclude(include, appContext) {
+  const defaultInclude = [appContext.internalDirectory];
+  const transformInclude = (include || []).map(include => {
+    if (typeof include === 'string') {
+      if ((0, _path.isAbsolute)(include)) {
+        return include;
+      }
+
+      return new RegExp(include);
+    }
+
+    return include;
+  }).concat(defaultInclude); // concat default Include
+
+  const root = (0, _utils.findMonorepoRoot)(appContext.appDirectory);
+
+  if (!root) {
+    return transformInclude;
+  }
+
+  const modernjsMonorepo = (0, _utils.isModernjsMonorepo)(root);
+
+  if (modernjsMonorepo) {
+    const paths = _utils.globby.sync(_path.posix.join(root, 'features', '**', 'package.json'), {
+      ignore: ['**/node_modules/**/*']
+    }).map(pathname => (0, _path.dirname)(pathname) + _path.sep);
+
+    return [...paths, ...transformInclude];
+  }
+
+  return transformInclude;
+}
+
+function createBuilderModuleScope(moduleScopes) {
+  if (moduleScopes) {
+    let builderModuleScope = [];
+    const DEFAULT_SCOPES = ['./src', './shared', /node_modules/];
+
+    if (Array.isArray(moduleScopes)) {
+      if (isPrimitiveScope(moduleScopes)) {
+        builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
+      } else {
+        builderModuleScope = [DEFAULT_SCOPES, ...moduleScopes];
+      }
+    } else {
+      builderModuleScope = [DEFAULT_SCOPES, moduleScopes];
+    }
+
+    return builderModuleScope;
+  } else {
+    return undefined;
+  }
+
+  function isPrimitiveScope(items) {
+    return items.every(item => typeof item === 'string' || Object.prototype.toString.call(item) === '[object RegExp]');
+  }
+}

package/dist/js/node/builder/createToolsConfig.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderTsChecker = createBuilderTsChecker;
+exports.createToolsConfig = createToolsConfig;
+
+var _utils = require("@modern-js/utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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; }
+
+function createToolsConfig(normalizedConfig) {
+  const {
+    disableCssExtract,
+    enableTsLoader
+  } = normalizedConfig.output;
+  const {
+    autoprefixer,
+    babel,
+    minifyCss,
+    terser,
+    webpack,
+    webpackChain,
+    tsLoader,
+    styledComponents,
+    sass,
+    postcss,
+    less,
+    htmlPlugin,
+    // TODO: remove modernjs tools.lodash config
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    lodash
+  } = normalizedConfig.tools;
+  const builderTsLoader = createBuilderTsLoader(tsLoader, enableTsLoader);
+  const builderTsChecker = createBuilderTsChecker(normalizedConfig.output);
+  return {
+    tsChecker: builderTsChecker,
+    styleLoader: disableCssExtract ? {} : undefined,
+    cssExtract: disableCssExtract ? false : undefined,
+    autoprefixer,
+    babel,
+    minifyCss,
+    terser,
+    webpack,
+    webpackChain: webpackChain,
+    tsLoader: builderTsLoader,
+    styledComponents: styledComponents,
+    sass: sass,
+    postcss: postcss,
+    less: less,
+    // can't remove comment in html minify.
+    // some html template insert by using those comments.
+    htmlPlugin: [config => _objectSpread(_objectSpread({}, config), {}, {
+      minify: typeof config.minify === 'object' ? _objectSpread(_objectSpread({}, config.minify), {}, {
+        removeComments: false
+      }) : config.minify
+    }), // eslint-disable-next-line no-nested-ternary
+    ...(Array.isArray(htmlPlugin) ? htmlPlugin : htmlPlugin ? [htmlPlugin] : [])]
+  };
+}
+
+function createBuilderTsLoader(tsLoader, enableTsLoader) {
+  const useTsLoader = Boolean(enableTsLoader);
+
+  if (!useTsLoader) {
+    return undefined;
+  }
+
+  const defaultTsLoader = {
+    compilerOptions: {
+      target: 'es5',
+      module: 'ESNext'
+    },
+    transpileOnly: false,
+    allowTsInNodeModules: true
+  };
+  return (_, utils) => (0, _utils.applyOptionsChain)(defaultTsLoader, tsLoader, utils);
+}
+
+function createBuilderTsChecker(output) {
+  if (output.enableTsLoader || output.disableTsChecker) {
+    return false;
+  }
+
+  const defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  return defaultTsChecker;
+}

package/dist/js/node/builder/index.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderOptions = createBuilderOptions;
+exports.default = void 0;
+
+var _builder = require("@modern-js/builder");
+
+var _builderWebpackProvider = require("@modern-js/builder-webpack-provider");
+
+var _utils = require("@modern-js/utils");
+
+var _compatModern = require("./builderPlugins/compatModern");
+
+var _createHtmlConfig = require("./createHtmlConfig");
+
+var _createOutputConfig = require("./createOutputConfig");
+
+var _createSourceConfig = require("./createSourceConfig");
+
+var _createToolsConfig = require("./createToolsConfig");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = async ({
+  target: _target = 'web',
+  normalizedConfig,
+  appContext,
+  compatPluginConfig
+}) => {
+  const targets = Array.isArray(_target) ? _target : [_target];
+
+  if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
+    targets.push('modern-web');
+  }
+
+  const builderConfig = createBuilderProviderConfig(normalizedConfig, appContext); // create webpack provider
+
+  const webpackProvider = (0, _builderWebpackProvider.builderWebpackProvider)({
+    builderConfig
+  });
+  const builderOptions = createBuilderOptions(_target, appContext);
+  const builder = await (0, _builder.createBuilder)(webpackProvider, builderOptions);
+  await applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig);
+  return builder;
+};
+
+exports.default = _default;
+
+function createBuilderProviderConfig(normalizedConfig, appContext) {
+  const source = (0, _createSourceConfig.createSourceConfig)(normalizedConfig, appContext);
+  const html = (0, _createHtmlConfig.createHtmlConfig)(normalizedConfig, appContext);
+  const output = (0, _createOutputConfig.createOutputConfig)(normalizedConfig, appContext);
+  const tools = (0, _createToolsConfig.createToolsConfig)(normalizedConfig);
+  return {
+    source,
+    html,
+    output,
+    tools,
+    performance: {
+      // `@modern-js/webpack` used to remove moment locale by default
+      removeMomentLocale: true
+    }
+  };
+}
+
+function createBuilderOptions(target, appContext) {
+  // create entries
+  const entries = {};
+  const {
+    entrypoints = [],
+    checkedEntries
+  } = appContext;
+
+  for (const {
+    entryName,
+    entry
+  } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+
+    if (entryName in entries) {
+      entries[entryName].push(entry);
+    } else {
+      entries[entryName] = [entry];
+    }
+  }
+
+  return {
+    cwd: appContext.appDirectory,
+    target,
+    configPath: appContext.configFile || undefined,
+    entry: entries,
+    framework: appContext.metaName
+  };
+}
+/**
+ * register builder Plugin by condition
+ */
+
+
+async function applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig) {
+  if (!normalizedConfig.output.disableNodePolyfill) {
+    const {
+      PluginNodePolyfill
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/builder-plugin-node-polyfill')));
+    builder.addPlugins([PluginNodePolyfill()]);
+  }
+
+  if (normalizedConfig.tools.esbuild) {
+    const {
+      esbuild: esbuildOptions
+    } = normalizedConfig.tools;
+    const {
+      PluginEsbuild
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/builder-plugin-esbuild')));
+    builder.addPlugins([PluginEsbuild({
+      loader: false,
+      minimize: (0, _utils.applyOptionsChain)({}, esbuildOptions)
+    })]);
+  }
+
+  builder.addPlugins([(0, _compatModern.PluginCompatModern)(appContext, normalizedConfig, compatPluginConfig)]);
+}

package/dist/js/node/builder/share.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCopyPattern = createCopyPattern;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _lodash = require("@modern-js/utils/lodash");
+
+var _utils = require("@modern-js/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createCopyPattern(appContext, config, patternsType, chain) {
+  const configDir = _path.default.resolve(appContext.appDirectory, config.source.configDir);
+
+  const uploadDir = _path.default.posix.join(configDir.replace(/\\/g, '/'), 'upload');
+
+  const publicDir = _path.default.posix.join(configDir.replace(/\\/g, '/'), 'public');
+
+  const minifiedJsRexExp = /\.min\.js/;
+
+  const info = file => ({
+    // If the file name ends with `.min.js`, we assume it's a compressed file.
+    // So we don't want copy-webpack-plugin to minify it.
+    // ref: https://github.com/webpack-contrib/copy-webpack-plugin#info
+    minimized: minifiedJsRexExp.test(file.sourceFilename)
+  });
+
+  if (patternsType === 'public') {
+    if (!chain) {
+      throw new Error("expect get a webpackChain, but receive 'undefined'");
+    }
+
+    return {
+      info,
+      from: '**/*',
+      to: 'public',
+      context: publicDir,
+      noErrorOnMissing: true,
+      // eslint-disable-next-line node/prefer-global/buffer
+      transform: (content, absoluteFrom) => {
+        if (!/\.html?$/.test(absoluteFrom)) {
+          return content;
+        }
+
+        return (0, _lodash.template)(content.toString('utf8'))({
+          assetPrefix: (0, _utils.removeTailSlash)(chain.output.get('publicPath'))
+        });
+      }
+    };
+  } else {
+    return {
+      info,
+      from: '**/*',
+      to: 'upload',
+      context: uploadDir,
+      noErrorOnMissing: true
+    };
+  }
+}

package/dist/js/node/builder/webpackPlugins/htmlAsyncChunkPlugin.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HtmlAsyncChunkPlugin = void 0;
+
+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; }
+
+class HtmlAsyncChunkPlugin {
+  constructor(htmlWebpackPlugin) {
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "htmlWebpackPlugin", void 0);
+
+    this.name = 'HtmlAsyncChunkPlugin';
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, compilation => {
+      const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.alterAssetTagGroups.tap(this.name, assets => {
+        const tags = [...assets.headTags, ...assets.bodyTags];
+
+        for (const tag of tags) {
+          if (tag.tagName === 'script') {
+            const {
+              attributes
+            } = tag;
+
+            if (attributes && attributes.defer === true) {
+              attributes.async = true;
+              delete attributes.defer;
+            }
+          }
+        }
+
+        return assets;
+      });
+    });
+  }
+
+}
+
+exports.HtmlAsyncChunkPlugin = HtmlAsyncChunkPlugin;

package/dist/js/node/builder/webpackPlugins/htmlBottomTemplate.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BottomTemplatePlugin = void 0;
+
+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; }
+
+class BottomTemplatePlugin {
+  constructor(htmlWebpackPlugin) {
+    _defineProperty(this, "htmlWebpackPlugin", void 0);
+
+    _defineProperty(this, "bottomTemplateReg", /<!--<\?-\s*bottomTemplate\s*\?>-->/);
+
+    _defineProperty(this, "bodyRegExp", /(<\/\s*body\s*>)/i);
+
+    _defineProperty(this, "name", void 0);
+
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+    this.name = 'bottom-template';
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, compilation => {
+      this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(this.name, data => {
+        var _data$plugin$options;
+
+        if (!((_data$plugin$options = data.plugin.options) !== null && _data$plugin$options !== void 0 && _data$plugin$options.__internal__)) {
+          return data;
+        } // 含有 <!--<?- bottomTemplate ?>--> 占位符时才需要注入 bottom.html
+
+
+        if (this.bottomTemplateReg.test(data.html)) {
+          // 清空占位符
+          data.html = data.html.replace(this.bottomTemplateReg, '');
+          const {
+            bottomTemplate
+          } = data.plugin.options;
+
+          if (bottomTemplate) {
+            data.html = data.html.replace(this.bodyRegExp, match => `\n${bottomTemplate}\n${match}`);
+          }
+        }
+
+        return data;
+      });
+    });
+  }
+
+}
+
+exports.BottomTemplatePlugin = BottomTemplatePlugin;

package/dist/js/node/commands/build.js

@@ -5,8 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.build = void 0;
 
-var _webpack = require("@modern-js/webpack");
-
 var _core = require("@modern-js/core");
 
 var _utils = require("@modern-js/utils");
@@ -15,16 +13,16 @@ var _routes = require("../utils/routes");
 
 var _config = require("../utils/config");
 
+var _builder = _interopRequireDefault(require("../builder"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
-// These sizes are pretty large. We'll warn for bundles exceeding them.
-const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
-const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
-
 const build = async (api, options) => {
   let resolvedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
@@ -39,9 +37,9 @@ const build = async (api, options) => {
       distDirectory,
       serverConfigFile
     } = appContext;
-    await (0, _utils.emptyDir)(distDirectory);
     await hookRunners.beforeBuild({
-      webpackConfigs: []
+      // "null" bundlerConfigs
+      bundlerConfigs: undefined
     });
     await (0, _config.buildServerConfig)({
       appDirectory,
@@ -49,64 +47,13 @@ const build = async (api, options) => {
       configFile: serverConfigFile
     });
     await (0, _routes.generateRoutes)(appContext);
-    await hookRunners.afterBuild();
+    await hookRunners.afterBuild({
+      // "null" stats
+      stats: undefined
+    });
     return;
   }
 
-  const webpackBuild = async (webpackConfig, type) => {
-    const compiler = (0, _webpack.webpack)(webpackConfig);
-    return new Promise((resolve, reject) => {
-      let label = process.env.NODE_ENV || '';
-
-      if (type && type !== 'legacy') {
-        label += ` ${type}`;
-      }
-
-      _utils.logger.info(`Creating a ${label} build...`);
-
-      compiler.run((err, stats) => {
-        let messages;
-
-        if (!err) {
-          messages = (0, _utils.formatWebpackMessages)(stats.toJson({
-            all: false,
-            warnings: true,
-            errors: true
-          }));
-
-          if (messages.errors.length === 0) {
-            _utils.logger.info(`File sizes after ${label} build:\n`);
-
-            (0, _utils.printFileSizesAfterBuild)(stats, previousFileSizes, distDirectory, WARN_AFTER_BUNDLE_GZIP_SIZE, WARN_AFTER_CHUNK_GZIP_SIZE);
-
-            _utils.logger.log();
-          }
-        } // When using run or watch, call close and wait for it to finish before calling run or watch again.
-        // Concurrent compilations will corrupt the output files.
-
-
-        compiler.close(closeErr => {
-          if (closeErr) {
-            _utils.logger.error(closeErr);
-          }
-
-          if (err) {
-            reject(err);
-          } else {
-            if (messages.errors.length) {
-              reject(new Error(messages.errors.join('\n\n')));
-              return;
-            }
-
-            resolve({
-              warnings: messages.warnings
-            });
-          }
-        });
-      });
-    });
-  };
-
   resolvedConfig = _objectSpread(_objectSpread({}, resolvedConfig), {}, {
     cliOptions: options
   });
@@ -118,57 +65,56 @@ const build = async (api, options) => {
     appDirectory,
     serverConfigFile
   } = appContext;
-  const previousFileSizes = await (0, _utils.measureFileSizesBeforeBuild)(distDirectory);
-  await (0, _utils.emptyDir)(distDirectory);
   await (0, _config.buildServerConfig)({
     appDirectory,
     distDirectory,
     configFile: serverConfigFile
   });
-  const buildConfigs = [];
-  buildConfigs.push({
-    type: 'legacy',
-    config: (0, _webpack.getWebpackConfig)(_webpack.WebpackConfigTarget.CLIENT, appContext, resolvedConfig)
-  });
+  const targets = ['web'];
 
   if (resolvedConfig.output.enableModernMode) {
-    buildConfigs.push({
-      type: 'modern',
-      config: (0, _webpack.getWebpackConfig)(_webpack.WebpackConfigTarget.MODERN, appContext, resolvedConfig)
-    });
+    targets.push('modern-web');
   }
 
   if ((0, _utils.isUseSSRBundle)(resolvedConfig)) {
-    buildConfigs.push({
-      type: 'ssr',
-      config: (0, _webpack.getWebpackConfig)(_webpack.WebpackConfigTarget.NODE, appContext, resolvedConfig)
-    });
+    targets.push('node');
   }
 
-  await hookRunners.beforeBuild({
-    webpackConfigs: buildConfigs.map(({
-      config
-    }) => config)
-  });
+  try {
+    const builder = await (0, _builder.default)({
+      target: targets,
+      appContext,
+      normalizedConfig: resolvedConfig,
+      compatPluginConfig: {
+        async onBeforeBuild({
+          bundlerConfigs
+        }) {
+          await (0, _routes.generateRoutes)(appContext);
+          await hookRunners.beforeBuild({
+            bundlerConfigs
+          });
+        },
+
+        async onAfterBuild({
+          stats
+        }) {
+          await hookRunners.afterBuild({
+            stats
+          });
+          await (0, _config.emitResolvedConfig)(appDirectory, resolvedConfig);
+        }
 
-  for (const buildConfig of buildConfigs) {
-    const {
-      type: buildType,
-      config
-    } = buildConfig;
+      }
+    });
 
-    try {
-      await webpackBuild(config, buildType);
-    } catch (error) {
-      (0, _utils.printBuildError)(error); // eslint-disable-next-line no-process-exit
+    _utils.logger.info('Create a production build...\n');
 
-      process.exit(1);
-    }
-  }
+    await builder.build();
+  } catch (error) {
+    (0, _utils.printBuildError)(error); // eslint-disable-next-line no-process-exit
 
-  await (0, _routes.generateRoutes)(appContext);
-  await hookRunners.afterBuild();
-  await (0, _config.emitResolvedConfig)(appDirectory, resolvedConfig);
+    process.exit(1);
+  }
 };
 
 exports.build = build;