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

package/dist/js/treeshaking/analyze/utils.js

@@ -0,0 +1,95 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import fs from 'fs';
+import path from 'path';
+import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
+import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
+export var walkDirectory = function walkDirectory(dir) {
+  return fs.readdirSync(dir).reduce(function (previous, filename) {
+    var filePath = path.join(dir, filename);
+
+    if (fs.statSync(filePath).isDirectory()) {
+      return [].concat(_toConsumableArray(previous), _toConsumableArray(walkDirectory(filePath)));
+    } else {
+      return [].concat(_toConsumableArray(previous), [filePath]);
+    }
+  }, []);
+};
+export var getDefaultImports = function getDefaultImports(_ref) {
+  var entrypoint = _ref.entrypoint,
+      srcDirectory = _ref.srcDirectory,
+      internalSrcAlias = _ref.internalSrcAlias,
+      internalDirAlias = _ref.internalDirAlias,
+      internalDirectory = _ref.internalDirectory;
+  var entryName = entrypoint.entryName,
+      fileSystemRoutes = entrypoint.fileSystemRoutes,
+      customBootstrap = entrypoint.customBootstrap,
+      entry = entrypoint.entry;
+  var imports = [{
+    specifiers: [{
+      local: 'React'
+    }],
+    value: 'react'
+  }, {
+    specifiers: [{
+      local: 'ReactDOM'
+    }],
+    value: isReact18(path.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
+  }, {
+    specifiers: [{
+      imported: 'createApp'
+    }, {
+      imported: 'bootstrap'
+    }],
+    value: '@modern-js/runtime'
+  }, customBootstrap && {
+    specifiers: [{
+      local: 'customBootstrap'
+    }],
+    value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
+  }].filter(Boolean);
+
+  if (fileSystemRoutes) {
+    var route = {
+      specifiers: [{
+        imported: 'routes'
+      }],
+      value: normalizeToPosixPath("".concat(internalDirAlias, "/").concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME))
+    };
+
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{
+          local: 'App'
+        }],
+        value: normalizeToPosixPath(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+      });
+    } else {
+      route.initialize = 'const App = false;';
+    }
+
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{
+        local: 'App'
+      }],
+      value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
+    });
+  }
+
+  return imports;
+};
+export var isRouteComponentFile = function isRouteComponentFile(filePath) {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+
+  if (['.js', '.jsx', '.ts', '.tsx'].includes(path.extname(filePath))) {
+    return true;
+  }
+
+  return false;
+};
+export var replaceWithAlias = function replaceWithAlias(base, filePath, alias) {
+  return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+};

package/dist/js/treeshaking/builder/builderPlugins/compatModern.js

@@ -0,0 +1,231 @@
+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 { join } from 'path';
+import { mergeBuilderConfig } from '@modern-js/builder-shared';
+import { template as lodashTemplate } from '@modern-js/utils/lodash';
+import HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
+import { getEntryOptions } from '@modern-js/utils';
+import { BottomTemplatePlugin } from "../webpackPlugins/htmlBottomTemplate";
+import { HtmlAsyncChunkPlugin } from "../webpackPlugins/htmlAsyncChunkPlugin";
+import { createCopyPattern } from "../share";
+
+/**
+ * Provides default configuration consistent with `@modern-js/webpack`
+ */
+export var PluginCompatModern = function PluginCompatModern(appContext, modernConfig, options) {
+  return {
+    name: 'builder-plugin-compat-modern',
+    setup: function setup(api) {
+      api.modifyBuilderConfig(function (config) {
+        if (isStreamingSSR(modernConfig)) {
+          return mergeBuilderConfig(config, {
+            html: {
+              inject: 'body'
+            }
+          });
+        }
+
+        return config;
+      });
+      api.modifyWebpackChain(function (chain, _ref) {
+        var target = _ref.target,
+            CHAIN_ID = _ref.CHAIN_ID,
+            isProd = _ref.isProd;
+        var builderNormalizedConfig = api.getNormalizedConfig(); // set webpack config name
+
+        if (target === 'node') {
+          chain.name('server');
+        } else if (target === 'modern-web') {
+          chain.name('modern');
+        } else {
+          chain.name('client');
+        }
+
+        chain.resolve.modules.add('node_modules').add(join(api.context.rootPath, 'node_modules')); // apply node compat
+
+        if (target === 'node') {
+          applyNodeCompat(chain, modernConfig, isProd);
+        }
+
+        if (isHtmlEnabled(builderNormalizedConfig, target)) {
+          applyBottomHtmlWebpackPlugin({
+            api: api,
+            chain: chain,
+            CHAIN_ID: CHAIN_ID,
+            appContext: appContext,
+            modernConfig: modernConfig
+          });
+          applyAsyncChunkHtmlPlugin({
+            chain: chain,
+            CHAIN_ID: CHAIN_ID,
+            modernConfig: modernConfig
+          });
+        } // apply copy plugin
+        // const copyPatterns = createCopyPatterns(chain, appContext, modernConfig);
+
+
+        var defaultCopyPattern = createCopyPattern(appContext, modernConfig, 'public', chain);
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap(function (args) {
+          var _args$;
+
+          return [{
+            patterns: [].concat(_toConsumableArray(((_args$ = args[0]) === null || _args$ === void 0 ? void 0 : _args$.patterns) || []), [defaultCopyPattern])
+          }];
+        });
+
+        function isHtmlEnabled(config, target) {
+          var _config$tools;
+
+          return ((_config$tools = config.tools) === null || _config$tools === void 0 ? void 0 : _config$tools.htmlPlugin) !== false && target !== 'node' && target !== 'web-worker';
+        }
+      });
+
+      if (options) {
+        applyCallbacks(api, options);
+      }
+    }
+  };
+};
+/**
+ * register builder hooks callback
+ */
+
+function applyCallbacks(api, options) {
+  options.onAfterBuild && api.onAfterBuild(options.onAfterBuild);
+  options.onAfterCreateCompiler && api.onAfterCreateCompiler(options.onAfterCreateCompiler);
+  options.onAfterStartDevServer && api.onAfterStartDevServer(options.onAfterStartDevServer);
+  options.onBeforeBuild && api.onBeforeBuild(options.onBeforeBuild);
+  options.onBeforeCreateCompiler && api.onBeforeCreateCompiler(options.onBeforeCreateCompiler);
+  options.onBeforeStartDevServer && api.onBeforeStartDevServer(options.onBeforeStartDevServer);
+  options.onDevCompileDone && api.onDevCompileDone(options.onDevCompileDone);
+  options.onExit && api.onExit(options.onExit);
+}
+/**
+ * compat some config, if target is `node`
+ */
+
+
+function applyNodeCompat(chain, modernConfig, isProd) {
+  // apply node resolve extensions
+  for (var _i = 0, _arr = ['.node.js', '.node.jsx', '.node.ts', '.node.tsx']; _i < _arr.length; _i++) {
+    var ext = _arr[_i];
+    chain.resolve.extensions.prepend(ext);
+  } // apply filterEntriesBySSRConfig
+
+
+  filterEntriesBySSRConfig(isProd, chain, modernConfig.server, modernConfig.output);
+
+  function filterEntriesBySSRConfig(isProd, chain, serverConfig, outputConfig) {
+    var _outputConfig$ssg;
+
+    var entries = chain.entryPoints.entries(); // if prod and ssg config is true or function
+
+    if (isProd && ((outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === true || typeof (outputConfig === null || outputConfig === void 0 ? void 0 : (_outputConfig$ssg = outputConfig.ssg) === null || _outputConfig$ssg === void 0 ? void 0 : _outputConfig$ssg[0]) === 'function')) {
+      return;
+    } // if single entry has ssg config
+    // `ssg: {}` is not allowed if multi entry
+
+
+    var entryNames = Object.keys(entries);
+
+    if (isProd && entryNames.length === 1 && outputConfig !== null && outputConfig !== void 0 && outputConfig.ssg) {
+      return;
+    } // collect all ssg entries
+
+
+    var ssgEntries = [];
+
+    if (isProd && outputConfig !== null && outputConfig !== void 0 && outputConfig.ssg) {
+      var ssg = outputConfig.ssg;
+      entryNames.forEach(function (name) {
+        if (ssg[name]) {
+          ssgEntries.push(name);
+        }
+      });
+    }
+
+    var _ref2 = serverConfig || {},
+        ssr = _ref2.ssr,
+        ssrByEntries = _ref2.ssrByEntries;
+
+    entryNames.forEach(function (name) {
+      if (!ssgEntries.includes(name) && (ssr && (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries !== null && ssrByEntries !== void 0 && ssrByEntries[name]))) {
+        chain.entryPoints["delete"](name);
+      }
+    });
+  }
+}
+/**
+ * inject bottom template
+ */
+
+
+function applyBottomHtmlWebpackPlugin(_ref3) {
+  var api = _ref3.api,
+      chain = _ref3.chain,
+      modernConfig = _ref3.modernConfig,
+      appContext = _ref3.appContext,
+      CHAIN_ID = _ref3.CHAIN_ID;
+
+  var _loop = function _loop() {
+    var entryName = _Object$keys[_i2];
+
+    // FIXME: the only need necessary
+    var baseTemplateParams = _objectSpread({
+      entryName: entryName,
+      title: getEntryOptions(entryName, modernConfig.output.title, modernConfig.output.titleByEntries, appContext.packageName),
+      mountId: modernConfig.output.mountId
+    }, getEntryOptions(entryName, modernConfig.output.templateParameters, modernConfig.output.templateParametersByEntries, appContext.packageName));
+
+    chain.plugin("".concat(CHAIN_ID.PLUGIN.HTML, "-").concat(entryName)).tap(function (args) {
+      return [_objectSpread(_objectSpread({}, args[0] || {}), {}, {
+        __internal__: true,
+        bottomTemplate: appContext.htmlTemplates["__".concat(entryName, "-bottom__")] && lodashTemplate(appContext.htmlTemplates["__".concat(entryName, "-bottom__")])(baseTemplateParams)
+      })];
+    });
+  };
+
+  // inject bottomTemplate into html-webpack-plugin
+  for (var _i2 = 0, _Object$keys = Object.keys(api.context.entry); _i2 < _Object$keys.length; _i2++) {
+    _loop();
+  }
+
+  chain.plugin(CHAIN_ID.PLUGIN.BOTTOM_TEMPLATE).use(BottomTemplatePlugin, [HtmlWebpackPlugin]);
+}
+
+var isStreamingSSR = function isStreamingSSR(userConfig) {
+  var isStreaming = function isStreaming(ssr) {
+    return ssr && _typeof(ssr) === 'object' && ssr.mode === 'stream';
+  };
+
+  var server = userConfig.server;
+
+  if (isStreaming(server.ssr)) {
+    return true;
+  } // Since we cannot apply different plugins for different entries,
+  // we regard the whole app as streaming ssr only if one entry meets the requirement.
+
+
+  if (server !== null && server !== void 0 && server.ssrByEntries && _typeof(server.ssrByEntries) === 'object') {
+    for (var _i3 = 0, _Object$keys2 = Object.keys(server.ssrByEntries); _i3 < _Object$keys2.length; _i3++) {
+      var name = _Object$keys2[_i3];
+
+      if (isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+function applyAsyncChunkHtmlPlugin(_ref4) {
+  var chain = _ref4.chain,
+      modernConfig = _ref4.modernConfig,
+      CHAIN_ID = _ref4.CHAIN_ID;
+
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin(CHAIN_ID.PLUGIN.HTML_ASYNC_CHUNK).use(HtmlAsyncChunkPlugin, [HtmlWebpackPlugin]);
+  }
+}

package/dist/js/treeshaking/builder/createHtmlConfig.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import { findExists } from '@modern-js/utils';
+export function createHtmlConfig(normalizedConfig, appContext) {
+  var _normalizedConfig$out = normalizedConfig.output,
+      disableHtmlFolder = _normalizedConfig$out.disableHtmlFolder,
+      favicon = _normalizedConfig$out.favicon,
+      faviconByEntries = _normalizedConfig$out.faviconByEntries,
+      inject = _normalizedConfig$out.inject,
+      injectByEntries = _normalizedConfig$out.injectByEntries,
+      meta = _normalizedConfig$out.meta,
+      metaByEntries = _normalizedConfig$out.metaByEntries,
+      mountId = _normalizedConfig$out.mountId,
+      title = _normalizedConfig$out.title,
+      titleByEntries = _normalizedConfig$out.titleByEntries,
+      scriptExt = _normalizedConfig$out.scriptExt,
+      templateParameters = _normalizedConfig$out.templateParameters,
+      templateParametersByEntries = _normalizedConfig$out.templateParametersByEntries;
+  var configDir = normalizedConfig.source.configDir; // transform Modernjs `output.scriptExt` to Builder `html.crossorigin`  configuration
+
+  var builderCrossorigin = createBuilderCrossorigin(scriptExt);
+  var builderAppIcon = createBuilderAppIcon(configDir, appContext);
+  var builderFavicon = createBuilderFavicon(favicon, configDir, appContext);
+  return {
+    appIcon: builderAppIcon,
+    disableHtmlFolder: disableHtmlFolder,
+    favicon: builderFavicon,
+    faviconByEntries: faviconByEntries,
+    inject: inject,
+    injectByEntries: injectByEntries,
+    meta: meta,
+    metaByEntries: metaByEntries,
+    mountId: mountId,
+    title: title,
+    titleByEntries: titleByEntries,
+    crossorigin: builderCrossorigin,
+    templateByEntries: appContext.htmlTemplates,
+    templateParameters: templateParameters,
+    templateParametersByEntries: templateParametersByEntries
+  };
+}
+var ICON_EXTENSIONS = ['png', 'jpg', 'jpeg', 'svg', 'ico'];
+export function createBuilderAppIcon(configDir, appContext) {
+  var appIcon = findExists(ICON_EXTENSIONS.map(function (ext) {
+    return path.resolve(appContext.appDirectory, configDir, "icon.".concat(ext));
+  }));
+  return typeof appIcon === 'string' ? appIcon : undefined;
+}
+export function createBuilderCrossorigin(scriptExt) {
+  var _scriptExtCustomConfi;
+
+  var scriptExtCustomConfig = scriptExt === null || scriptExt === void 0 ? void 0 : scriptExt.custom;
+  return scriptExtCustomConfig !== null && scriptExtCustomConfig !== void 0 && (_scriptExtCustomConfi = scriptExtCustomConfig.test) !== null && _scriptExtCustomConfi !== void 0 && _scriptExtCustomConfi.test('.js') && (scriptExtCustomConfig === null || scriptExtCustomConfig === void 0 ? void 0 : scriptExtCustomConfig.attribute) === 'crossorigin' ? scriptExtCustomConfig.value : undefined;
+}
+export function createBuilderFavicon(favicon, configDir, appContext) {
+  var defaultFavicon = findExists(ICON_EXTENSIONS.map(function (ext) {
+    return path.resolve(appContext.appDirectory, configDir, "favicon.".concat(ext));
+  }));
+  return favicon || defaultFavicon || undefined;
+}

package/dist/js/treeshaking/builder/createOutputConfig.js

@@ -0,0 +1,67 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createCopyPattern } from "./share";
+export function createOutputConfig(normalizedConfig, appContext) {
+  // TODO: add `externals` options in Modern.
+  var _normalizedConfig$out = normalizedConfig.output,
+      assetPrefix = _normalizedConfig$out.assetPrefix,
+      copy = _normalizedConfig$out.copy,
+      cssModuleLocalIdentName = _normalizedConfig$out.cssModuleLocalIdentName,
+      cssPath = _normalizedConfig$out.cssPath,
+      jsPath = _normalizedConfig$out.jsPath,
+      htmlPath = _normalizedConfig$out.htmlPath,
+      mediaPath = _normalizedConfig$out.mediaPath,
+      path = _normalizedConfig$out.path,
+      disableInlineRuntimeChunk = _normalizedConfig$out.disableInlineRuntimeChunk,
+      disableMinimize = _normalizedConfig$out.disableMinimize,
+      disableSourceMap = _normalizedConfig$out.disableSourceMap,
+      enableCssModuleTSDeclaration = _normalizedConfig$out.enableCssModuleTSDeclaration,
+      enableInlineScripts = _normalizedConfig$out.enableInlineScripts,
+      enableInlineStyles = _normalizedConfig$out.enableInlineStyles,
+      polyfill = _normalizedConfig$out.polyfill,
+      dataUriLimit = _normalizedConfig$out.dataUriLimit,
+      disableAssetsCache = _normalizedConfig$out.disableAssetsCache,
+      enableLatestDecorators = _normalizedConfig$out.enableLatestDecorators,
+      disableCssModuleExtension = _normalizedConfig$out.disableCssModuleExtension;
+  var defaultCopyPattern = createCopyPattern(appContext, normalizedConfig, 'upload');
+  var builderCopy = copy ? [].concat(_toConsumableArray(copy), [defaultCopyPattern]) : [defaultCopyPattern];
+  return {
+    assetPrefix: assetPrefix,
+    copy: builderCopy,
+    distPath: {
+      root: path,
+      css: cssPath,
+      js: jsPath,
+      html: htmlPath,
+      // `@modern-js/webpack` output all media files to `dist/media` by default
+      svg: mediaPath || 'midia',
+      image: mediaPath || 'midia',
+      font: mediaPath || 'midia',
+      media: mediaPath || 'midia'
+    },
+    dataUriLimit: {
+      svg: dataUriLimit,
+      image: dataUriLimit,
+      font: dataUriLimit,
+      media: dataUriLimit
+    },
+    disableCssModuleExtension: disableCssModuleExtension,
+    disableInlineRuntimeChunk: disableInlineRuntimeChunk,
+    disableMinimize: disableMinimize,
+    disableSourceMap: disableSourceMap,
+    enableCssModuleTSDeclaration: enableCssModuleTSDeclaration,
+    enableInlineScripts: enableInlineScripts,
+    enableInlineStyles: enableInlineStyles,
+    polyfill: polyfill,
+    // We need to do this in the app-tools prepare hook because some files will be generated into the dist directory in the analyze process
+    cleanDistPath: false,
+    disableFilenameHash: disableAssetsCache,
+    enableLatestDecorators: enableLatestDecorators,
+    filename: {
+      css: cssModuleLocalIdentName
+    },
+    // `@modern-js/webpack` used to generate asset manifest by default
+    enableAssetManifest: true,
+    // compatible the modern-js with fallback behavior
+    enableAssetFallback: true
+  };
+}

package/dist/js/treeshaking/builder/createSourceConfig.js

@@ -0,0 +1,100 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { dirname, isAbsolute, posix, sep } from 'path';
+import { globby, mergeAlias, findMonorepoRoot, isModernjsMonorepo } from '@modern-js/utils';
+export function createSourceConfig(normalizedConfig, appContext) {
+  var _normalizedConfig$sou = normalizedConfig.source,
+      alias = _normalizedConfig$sou.alias,
+      envVars = _normalizedConfig$sou.envVars,
+      globalVars = _normalizedConfig$sou.globalVars,
+      include = _normalizedConfig$sou.include,
+      moduleScopes = _normalizedConfig$sou.moduleScopes,
+      preEntry = _normalizedConfig$sou.preEntry;
+  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();
+  }
+
+  var builderModuleScope = createBuilderModuleScope(moduleScopes);
+  var builderInclude = createBuilderInclude(include, appContext);
+  return {
+    alias: mergeAlias(alias),
+    moduleScopes: builderModuleScope,
+    globalVars: builderGlobalVars,
+    include: builderInclude,
+    preEntry: preEntry,
+    // ensure resolve.extensions same as before
+    resolveExtensionPrefix: '.web'
+  };
+}
+export function createBuilderInclude(include, appContext) {
+  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;
+}
+export function createBuilderModuleScope(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]';
+    });
+  }
+}

package/dist/js/treeshaking/builder/createToolsConfig.js

@@ -0,0 +1,90 @@
+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 { applyOptionsChain } from '@modern-js/utils';
+export function createToolsConfig(normalizedConfig) {
+  var _normalizedConfig$out = normalizedConfig.output,
+      disableCssExtract = _normalizedConfig$out.disableCssExtract,
+      enableTsLoader = _normalizedConfig$out.enableTsLoader;
+  var _normalizedConfig$too = normalizedConfig.tools,
+      autoprefixer = _normalizedConfig$too.autoprefixer,
+      babel = _normalizedConfig$too.babel,
+      minifyCss = _normalizedConfig$too.minifyCss,
+      terser = _normalizedConfig$too.terser,
+      webpack = _normalizedConfig$too.webpack,
+      webpackChain = _normalizedConfig$too.webpackChain,
+      tsLoader = _normalizedConfig$too.tsLoader,
+      styledComponents = _normalizedConfig$too.styledComponents,
+      sass = _normalizedConfig$too.sass,
+      postcss = _normalizedConfig$too.postcss,
+      less = _normalizedConfig$too.less,
+      htmlPlugin = _normalizedConfig$too.htmlPlugin,
+      lodash = _normalizedConfig$too.lodash;
+  var builderTsLoader = createBuilderTsLoader(tsLoader, enableTsLoader);
+  var builderTsChecker = createBuilderTsChecker(normalizedConfig.output);
+  return {
+    tsChecker: builderTsChecker,
+    styleLoader: disableCssExtract ? {} : undefined,
+    cssExtract: disableCssExtract ? false : undefined,
+    autoprefixer: autoprefixer,
+    babel: babel,
+    minifyCss: minifyCss,
+    terser: terser,
+    webpack: 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: [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] : []))
+  };
+}
+
+function createBuilderTsLoader(tsLoader, enableTsLoader) {
+  var useTsLoader = Boolean(enableTsLoader);
+
+  if (!useTsLoader) {
+    return undefined;
+  }
+
+  var defaultTsLoader = {
+    compilerOptions: {
+      target: 'es5',
+      module: 'ESNext'
+    },
+    transpileOnly: false,
+    allowTsInNodeModules: true
+  };
+  return function (_, utils) {
+    return applyOptionsChain(defaultTsLoader, tsLoader, utils);
+  };
+}
+
+export function createBuilderTsChecker(output) {
+  if (output.enableTsLoader || output.disableTsChecker) {
+    return false;
+  }
+
+  var defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  return defaultTsChecker;
+}