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

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,70 @@
+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,
+    disableTsChecker = _normalizedConfig$out.disableTsChecker,
+    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 || 'media',
+      image: mediaPath || 'media',
+      font: mediaPath || 'media',
+      media: mediaPath || 'media'
+    },
+    dataUriLimit: {
+      svg: dataUriLimit,
+      image: dataUriLimit,
+      font: dataUriLimit,
+      media: dataUriLimit
+    },
+    disableCssModuleExtension: disableCssModuleExtension,
+    disableInlineRuntimeChunk: disableInlineRuntimeChunk,
+    disableMinimize: disableMinimize,
+    disableSourceMap: disableSourceMap,
+    disableTsChecker: disableTsChecker,
+    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,88 @@
+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,85 @@
+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) {
+    return false;
+  }
+  var defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  return defaultTsChecker;
+}

package/dist/js/treeshaking/builder/index.js

@@ -0,0 +1,161 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createBuilder } from '@modern-js/builder';
+import { builderWebpackProvider } from '@modern-js/builder-webpack-provider';
+import { applyOptionsChain, isUseSSRBundle } from '@modern-js/utils';
+import { PluginCompatModern } from "./builderPlugins/compatModern";
+import { createHtmlConfig } from "./createHtmlConfig";
+import { createOutputConfig } from "./createOutputConfig";
+import { createSourceConfig } from "./createSourceConfig";
+import { createToolsConfig } from "./createToolsConfig";
+function getBuilderTargets(normalizedConfig) {
+  var targets = ['web'];
+  if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
+    targets.push('modern-web');
+  }
+  if (isUseSSRBundle(normalizedConfig)) {
+    targets.push('node');
+  }
+  return targets;
+}
+export function createBuilderForEdenX(_x) {
+  return _createBuilderForEdenX.apply(this, arguments);
+}
+function _createBuilderForEdenX() {
+  _createBuilderForEdenX = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var normalizedConfig, appContext, compatPluginConfig, builderConfig, webpackProvider, target, builderOptions, builder;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            normalizedConfig = _ref.normalizedConfig, appContext = _ref.appContext, compatPluginConfig = _ref.compatPluginConfig;
+            builderConfig = createBuilderProviderConfig(normalizedConfig, appContext); // create webpack provider
+            webpackProvider = builderWebpackProvider({
+              builderConfig: builderConfig
+            });
+            target = getBuilderTargets(normalizedConfig);
+            builderOptions = createBuilderOptions(target, appContext);
+            _context.next = 7;
+            return createBuilder(webpackProvider, builderOptions);
+          case 7:
+            builder = _context.sent;
+            _context.next = 10;
+            return applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig);
+          case 10:
+            return _context.abrupt("return", builder);
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _createBuilderForEdenX.apply(this, arguments);
+}
+function createBuilderProviderConfig(normalizedConfig, appContext) {
+  var source = createSourceConfig(normalizedConfig, appContext);
+  var html = createHtmlConfig(normalizedConfig, appContext);
+  var output = createOutputConfig(normalizedConfig, appContext);
+  var tools = createToolsConfig(normalizedConfig);
+  return {
+    source: source,
+    html: html,
+    output: output,
+    tools: tools,
+    dev: {
+      https: normalizedConfig.dev.https,
+      assetPrefix: normalizedConfig.dev.assetPrefix
+    },
+    performance: {
+      // `@modern-js/webpack` used to remove moment locale by default
+      removeMomentLocale: true
+    }
+  };
+}
+export function createBuilderOptions(target, appContext) {
+  // create entries
+
+  var entries = {};
+  var _appContext$entrypoin = appContext.entrypoints,
+    entrypoints = _appContext$entrypoin === void 0 ? [] : _appContext$entrypoin,
+    checkedEntries = appContext.checkedEntries;
+  var _iterator = _createForOfIteratorHelper(entrypoints),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        entryName = _step$value.entryName,
+        entry = _step$value.entry;
+      if (checkedEntries && !checkedEntries.includes(entryName)) {
+        continue;
+      }
+      if (entryName in entries) {
+        entries[entryName].push(entry);
+      } else {
+        entries[entryName] = [entry];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    cwd: appContext.appDirectory,
+    target: target,
+    configPath: appContext.configFile || undefined,
+    entry: entries,
+    framework: appContext.metaName
+  };
+}
+
+/**
+ * register builder Plugin by condition
+ */
+function applyBuilderPlugins(_x2, _x3, _x4, _x5) {
+  return _applyBuilderPlugins.apply(this, arguments);
+}
+function _applyBuilderPlugins() {
+  _applyBuilderPlugins = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(builder, normalizedConfig, appContext, compatPluginConfig) {
+    var _yield$import, PluginNodePolyfill, esbuildOptions, _yield$import2, PluginEsbuild;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (normalizedConfig.output.disableNodePolyfill) {
+              _context2.next = 6;
+              break;
+            }
+            _context2.next = 3;
+            return import('@modern-js/builder-plugin-node-polyfill');
+          case 3:
+            _yield$import = _context2.sent;
+            PluginNodePolyfill = _yield$import.PluginNodePolyfill;
+            builder.addPlugins([PluginNodePolyfill()]);
+          case 6:
+            if (!normalizedConfig.tools.esbuild) {
+              _context2.next = 13;
+              break;
+            }
+            esbuildOptions = normalizedConfig.tools.esbuild;
+            _context2.next = 10;
+            return import('@modern-js/builder-plugin-esbuild');
+          case 10:
+            _yield$import2 = _context2.sent;
+            PluginEsbuild = _yield$import2.PluginEsbuild;
+            builder.addPlugins([PluginEsbuild({
+              loader: false,
+              minimize: applyOptionsChain({}, esbuildOptions)
+            })]);
+          case 13:
+            builder.addPlugins([PluginCompatModern(appContext, normalizedConfig, compatPluginConfig)]);
+          case 14:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _applyBuilderPlugins.apply(this, arguments);
+}

package/dist/js/treeshaking/builder/share.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import { template as lodashTemplate } from '@modern-js/utils/lodash';
+import { removeTailSlash } from '@modern-js/utils';
+export function createCopyPattern(appContext, config, patternsType, chain) {
+  var configDir = path.resolve(appContext.appDirectory, config.source.configDir);
+  var uploadDir = path.posix.join(configDir.replace(/\\/g, '/'), 'upload');
+  var publicDir = path.posix.join(configDir.replace(/\\/g, '/'), 'public');
+  var minifiedJsRexExp = /\.min\.js/;
+  var info = function info(file) {
+    return {
+      // 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: info,
+      from: '**/*',
+      to: 'public',
+      context: publicDir,
+      noErrorOnMissing: true,
+      // eslint-disable-next-line node/prefer-global/buffer
+      transform: function transform(content, absoluteFrom) {
+        if (!/\.html?$/.test(absoluteFrom)) {
+          return content;
+        }
+        return lodashTemplate(content.toString('utf8'))({
+          assetPrefix: removeTailSlash(chain.output.get('publicPath'))
+        });
+      }
+    };
+  } else {
+    return {
+      info: info,
+      from: '**/*',
+      to: 'upload',
+      context: uploadDir,
+      noErrorOnMissing: true
+    };
+  }
+}

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

@@ -0,0 +1,46 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var HtmlAsyncChunkPlugin = /*#__PURE__*/function () {
+  function HtmlAsyncChunkPlugin(htmlWebpackPlugin) {
+    _classCallCheck(this, HtmlAsyncChunkPlugin);
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "htmlWebpackPlugin", void 0);
+    this.name = 'HtmlAsyncChunkPlugin';
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+  }
+  _createClass(HtmlAsyncChunkPlugin, [{
+    key: "apply",
+    value: function apply(compiler) {
+      var _this = this;
+      compiler.hooks.compilation.tap(this.name, function (compilation) {
+        var hooks = _this.htmlWebpackPlugin.getHooks(compilation);
+        hooks.alterAssetTagGroups.tap(_this.name, function (assets) {
+          var tags = [].concat(_toConsumableArray(assets.headTags), _toConsumableArray(assets.bodyTags));
+          var _iterator = _createForOfIteratorHelper(tags),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var tag = _step.value;
+              if (tag.tagName === 'script') {
+                var attributes = tag.attributes;
+                if (attributes && attributes.defer === true) {
+                  attributes.async = true;
+                  delete attributes.defer;
+                }
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          return assets;
+        });
+      });
+    }
+  }]);
+  return HtmlAsyncChunkPlugin;
+}();

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

@@ -0,0 +1,41 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var BottomTemplatePlugin = /*#__PURE__*/function () {
+  function BottomTemplatePlugin(htmlWebpackPlugin) {
+    _classCallCheck(this, BottomTemplatePlugin);
+    _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';
+  }
+  _createClass(BottomTemplatePlugin, [{
+    key: "apply",
+    value: function apply(compiler) {
+      var _this = this;
+      compiler.hooks.compilation.tap(this.name, function (compilation) {
+        _this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(_this.name, function (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, '');
+            var bottomTemplate = data.plugin.options.bottomTemplate;
+            if (bottomTemplate) {
+              data.html = data.html.replace(_this.bodyRegExp, function (match) {
+                return "\n".concat(bottomTemplate, "\n").concat(match);
+              });
+            }
+          }
+          return data;
+        });
+      });
+    }
+  }]);
+  return BottomTemplatePlugin;
+}();