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

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

@@ -0,0 +1,172 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createBuilder } from '@modern-js/builder';
+import { builderWebpackProvider } from '@modern-js/builder-webpack-provider';
+import { applyOptionsChain } 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";
+export default /*#__PURE__*/(function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var _ref$target, target, normalizedConfig, appContext, compatPluginConfig, targets, builderConfig, webpackProvider, builderOptions, builder;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _ref$target = _ref.target, target = _ref$target === void 0 ? 'web' : _ref$target, normalizedConfig = _ref.normalizedConfig, appContext = _ref.appContext, compatPluginConfig = _ref.compatPluginConfig;
+            targets = Array.isArray(target) ? target : [target];
+
+            if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
+              targets.push('modern-web');
+            }
+
+            builderConfig = createBuilderProviderConfig(normalizedConfig, appContext); // create webpack provider
+
+            webpackProvider = builderWebpackProvider({
+              builderConfig: builderConfig
+            });
+            builderOptions = createBuilderOptions(target, appContext);
+            _context.next = 8;
+            return createBuilder(webpackProvider, builderOptions);
+
+          case 8:
+            builder = _context.sent;
+            _context.next = 11;
+            return applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig);
+
+          case 11:
+            return _context.abrupt("return", builder);
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x) {
+    return _ref2.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,
+    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,50 @@
+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,58 @@
+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,53 @@
+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;
+}();

package/dist/js/treeshaking/commands/build.js

@@ -0,0 +1,168 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { ResolvedConfigContext } from '@modern-js/core';
+import { logger, isUseSSRBundle, printBuildError } from '@modern-js/utils';
+import { generateRoutes } from "../utils/routes";
+import { buildServerConfig, emitResolvedConfig } from "../utils/config";
+import createBuilder from "../builder";
+export var build = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(api, options) {
+    var resolvedConfig, appContext, hookRunners, apiOnly, _appDirectory, _distDirectory, _serverConfigFile, distDirectory, appDirectory, serverConfigFile, targets, builder;
+
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            resolvedConfig = api.useResolvedConfigContext();
+            appContext = api.useAppContext();
+            hookRunners = api.useHookRunners();
+            apiOnly = appContext.apiOnly;
+
+            if (!apiOnly) {
+              _context3.next = 15;
+              break;
+            }
+
+            _appDirectory = appContext.appDirectory, _distDirectory = appContext.distDirectory, _serverConfigFile = appContext.serverConfigFile;
+            _context3.next = 8;
+            return hookRunners.beforeBuild({
+              // "null" bundlerConfigs
+              bundlerConfigs: undefined
+            });
+
+          case 8:
+            _context3.next = 10;
+            return buildServerConfig({
+              appDirectory: _appDirectory,
+              distDirectory: _distDirectory,
+              configFile: _serverConfigFile
+            });
+
+          case 10:
+            _context3.next = 12;
+            return generateRoutes(appContext);
+
+          case 12:
+            _context3.next = 14;
+            return hookRunners.afterBuild({
+              // "null" stats
+              stats: undefined
+            });
+
+          case 14:
+            return _context3.abrupt("return");
+
+          case 15:
+            resolvedConfig = _objectSpread(_objectSpread({}, resolvedConfig), {}, {
+              cliOptions: options
+            });
+            ResolvedConfigContext.set(resolvedConfig);
+            distDirectory = appContext.distDirectory, appDirectory = appContext.appDirectory, serverConfigFile = appContext.serverConfigFile;
+            _context3.next = 20;
+            return buildServerConfig({
+              appDirectory: appDirectory,
+              distDirectory: distDirectory,
+              configFile: serverConfigFile
+            });
+
+          case 20:
+            targets = ['web'];
+
+            if (resolvedConfig.output.enableModernMode) {
+              targets.push('modern-web');
+            }
+
+            if (isUseSSRBundle(resolvedConfig)) {
+              targets.push('node');
+            }
+
+            _context3.prev = 23;
+            _context3.next = 26;
+            return createBuilder({
+              target: targets,
+              appContext: appContext,
+              normalizedConfig: resolvedConfig,
+              compatPluginConfig: {
+                onBeforeBuild: function onBeforeBuild(_ref2) {
+                  return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                    var bundlerConfigs;
+                    return _regeneratorRuntime().wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            bundlerConfigs = _ref2.bundlerConfigs;
+                            _context.next = 3;
+                            return generateRoutes(appContext);
+
+                          case 3:
+                            _context.next = 5;
+                            return hookRunners.beforeBuild({
+                              bundlerConfigs: bundlerConfigs
+                            });
+
+                          case 5:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }))();
+                },
+                onAfterBuild: function onAfterBuild(_ref3) {
+                  return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                    var stats;
+                    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            stats = _ref3.stats;
+                            _context2.next = 3;
+                            return hookRunners.afterBuild({
+                              stats: stats
+                            });
+
+                          case 3:
+                            _context2.next = 5;
+                            return emitResolvedConfig(appDirectory, resolvedConfig);
+
+                          case 5:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }))();
+                }
+              }
+            });
+
+          case 26:
+            builder = _context3.sent;
+            logger.info('Create a production build...\n');
+            _context3.next = 30;
+            return builder.build();
+
+          case 30:
+            _context3.next = 36;
+            break;
+
+          case 32:
+            _context3.prev = 32;
+            _context3.t0 = _context3["catch"](23);
+            printBuildError(_context3.t0); // eslint-disable-next-line no-process-exit
+
+            process.exit(1);
+
+          case 36:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[23, 32]]);
+  }));
+
+  return function build(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/commands/deploy.js

@@ -0,0 +1,29 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+export var deploy = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(api, options) {
+    var hookRunners;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            hookRunners = api.useHookRunners();
+            _context.next = 3;
+            return hookRunners.beforeDeploy(options);
+
+          case 3:
+            _context.next = 5;
+            return hookRunners.afterDeploy(options);
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function deploy(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/commands/dev.js

@@ -0,0 +1,146 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { logger, isSSR } from '@modern-js/utils';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { printInstructions } from "../utils/printInstructions";
+import { createDevCompiler } from "../utils/createCompiler";
+import { createServer, injectDataLoaderPlugin } from "../utils/createServer";
+import { generateRoutes } from "../utils/routes";
+import { getSpecifiedEntries } from "../utils/getSpecifiedEntries";
+import { buildServerConfig } from "../utils/config";
+export var dev = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(api, options) {
+    var userConfig, appContext, hookRunners, appDirectory, distDirectory, port, apiOnly, entrypoints, serverConfigFile, serverInternalPlugins, checkedEntries, compiler, target, app;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            userConfig = api.useResolvedConfigContext();
+            appContext = api.useAppContext();
+            hookRunners = api.useHookRunners();
+            userConfig = _objectSpread(_objectSpread({}, userConfig), {}, {
+              cliOptions: options
+            });
+            ResolvedConfigContext.set(userConfig);
+            appDirectory = appContext.appDirectory, distDirectory = appContext.distDirectory, port = appContext.port, apiOnly = appContext.apiOnly, entrypoints = appContext.entrypoints, serverConfigFile = appContext.serverConfigFile, serverInternalPlugins = appContext.serverInternalPlugins;
+            _context2.next = 8;
+            return getSpecifiedEntries(options.entry || false, entrypoints);
+
+          case 8:
+            checkedEntries = _context2.sent;
+            api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+              checkedEntries: checkedEntries
+            }));
+            appContext.checkedEntries = checkedEntries;
+            _context2.next = 13;
+            return buildServerConfig({
+              appDirectory: appDirectory,
+              distDirectory: distDirectory,
+              configFile: serverConfigFile,
+              options: {
+                esbuildOptions: {
+                  watch: true
+                }
+              }
+            });
+
+          case 13:
+            _context2.next = 15;
+            return hookRunners.beforeDev();
+
+          case 15:
+            compiler = null;
+
+            if (apiOnly) {
+              _context2.next = 21;
+              break;
+            }
+
+            target = isSSR(userConfig) ? ['web', 'node'] : ['web'];
+            _context2.next = 20;
+            return createDevCompiler({
+              target: target,
+              api: api,
+              normalizedConfig: userConfig,
+              appContext: appContext
+            });
+
+          case 20:
+            compiler = _context2.sent;
+
+          case 21:
+            _context2.next = 23;
+            return generateRoutes(appContext);
+
+          case 23:
+            _context2.next = 25;
+            return createServer({
+              dev: _objectSpread(_objectSpread({}, {
+                client: {
+                  port: port.toString()
+                },
+                devMiddleware: {
+                  writeToDisk: function writeToDisk(file) {
+                    return !file.includes('.hot-update.');
+                  }
+                },
+                hot: true,
+                liveReload: true,
+                port: port,
+                https: userConfig.dev.https
+              }), userConfig.tools.devServer),
+              compiler: compiler,
+              pwd: appDirectory,
+              config: userConfig,
+              serverConfigFile: serverConfigFile,
+              internalPlugins: injectDataLoaderPlugin(serverInternalPlugins)
+            });
+
+          case 25:
+            app = _context2.sent;
+            app.listen(port, /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(err) {
+                return _regeneratorRuntime().wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        if (!err) {
+                          _context.next = 2;
+                          break;
+                        }
+
+                        throw err;
+
+                      case 2:
+                        if (!apiOnly) {
+                          logger.info("Starting dev server...");
+                        } else {
+                          printInstructions(hookRunners, appContext, userConfig);
+                        }
+
+                      case 3:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x3) {
+                return _ref2.apply(this, arguments);
+              };
+            }());
+
+          case 27:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function dev(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/commands/index.js

@@ -0,0 +1,3 @@
+export * from "./dev";
+export * from "./build";
+export * from "./start";