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

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

@@ -0,0 +1,121 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import path from 'path';
+import { fs, ROUTE_MANIFEST, logger, ROUTE_MINIFEST_FILE } from '@modern-js/utils';
+var PLUGIN_NAME = 'ModernjsRoutePlugin';
+var RouterPlugin = /*#__PURE__*/function () {
+  function RouterPlugin(options) {
+    _classCallCheck(this, RouterPlugin);
+    _defineProperty(this, "existNestedRoutes", void 0);
+    this.existNestedRoutes = options.existNestedRoutes;
+  }
+  _createClass(RouterPlugin, [{
+    key: "apply",
+    value: function apply(compiler) {
+      var existNestedRoutes = this.existNestedRoutes;
+      var target = compiler.options.target;
+      if (target === 'node' || Array.isArray(target) && target.includes('node')) {
+        return;
+      }
+      if (!existNestedRoutes) {
+        return;
+      }
+      var webpack = compiler.webpack;
+      var Compilation = webpack.Compilation,
+        sources = webpack.sources;
+      var RawSource = sources.RawSource;
+      var PROCESS_ASSETS_STAGE_REPORT = Compilation.PROCESS_ASSETS_STAGE_REPORT;
+      var outputPath = compiler.options.output.path;
+      var newAssetsMap = new Map();
+      var normalizePath = function normalizePath(path) {
+        if (!path.endsWith('/')) {
+          return "".concat(path, "/");
+        }
+        return path;
+      };
+      compiler.hooks.thisCompilation.tap(PLUGIN_NAME, function (compilation) {
+        compilation.hooks.processAssets.tapPromise({
+          name: PLUGIN_NAME,
+          stage: PROCESS_ASSETS_STAGE_REPORT
+        }, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+          var stats, publicPath, routeAssets, namedChunkGroups, assetsByChunkName, _i, _Object$entries, _Object$entries$_i, name, chunkGroup, manifest, injectedContent, entrypointsArray, entryChunkIds, entryChunks, entryChunkFiles, _iterator, _step, file, asset, newContent, filename;
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  stats = compilation.getStats().toJson({
+                    chunkGroups: true,
+                    chunks: true
+                  });
+                  publicPath = stats.publicPath;
+                  routeAssets = {};
+                  namedChunkGroups = stats.namedChunkGroups, assetsByChunkName = stats.assetsByChunkName;
+                  if (!(!namedChunkGroups || !assetsByChunkName)) {
+                    _context.next = 7;
+                    break;
+                  }
+                  logger.warn('Route manifest does not exist, performance will be affected');
+                  return _context.abrupt("return");
+                case 7:
+                  for (_i = 0, _Object$entries = Object.entries(namedChunkGroups); _i < _Object$entries.length; _i++) {
+                    _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), name = _Object$entries$_i[0], chunkGroup = _Object$entries$_i[1];
+                    routeAssets[name] = {
+                      chunkIds: chunkGroup.chunks,
+                      assets: assetsByChunkName[name].map(function (item) {
+                        return publicPath ? normalizePath(publicPath) + item : item;
+                      })
+                    };
+                  }
+                  manifest = {
+                    routeAssets: routeAssets
+                  };
+                  injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest), ";\n            })();\n          ");
+                  entrypointsArray = Array.from(compilation.entrypoints.entries());
+                  entryChunkIds = entrypointsArray.map(function (entrypoint) {
+                    return entrypoint[0];
+                  });
+                  entryChunks = _toConsumableArray(compilation.chunks).filter(function (chunk) {
+                    return entryChunkIds.includes(chunk.name);
+                  });
+                  entryChunkFiles = entryChunks.map(function (chunk) {
+                    return _toConsumableArray(chunk.files)[0];
+                  });
+                  _iterator = _createForOfIteratorHelper(entryChunkFiles);
+                  try {
+                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                      file = _step.value;
+                      asset = compilation.assets[file];
+                      newContent = "".concat(injectedContent).concat(asset.source().toString());
+                      newAssetsMap.set(path.join(outputPath, file), newContent);
+                      compilation.updateAsset(file, new RawSource(newContent));
+                    }
+                  } catch (err) {
+                    _iterator.e(err);
+                  } finally {
+                    _iterator.f();
+                  }
+                  filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+                  _context.next = 19;
+                  return fs.ensureFile(filename);
+                case 19:
+                  _context.next = 21;
+                  return fs.writeFile(filename, JSON.stringify(manifest, null, 2));
+                case 21:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        })));
+      });
+    }
+  }]);
+  return RouterPlugin;
+}();
+export { RouterPlugin as default };

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

@@ -0,0 +1,83 @@
+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, printBuildError } from '@modern-js/utils';
+import { generateRoutes } from "../utils/routes";
+import { buildServerConfig } from "../utils/config";
+export var build = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(api, options) {
+    var resolvedConfig, appContext, hookRunners, apiOnly, _appDirectory, _distDirectory, _serverConfigFile, distDirectory, appDirectory, serverConfigFile, _appContext$builder;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            resolvedConfig = api.useResolvedConfigContext();
+            appContext = api.useAppContext();
+            hookRunners = api.useHookRunners();
+            apiOnly = appContext.apiOnly;
+            if (!apiOnly) {
+              _context.next = 15;
+              break;
+            }
+            _appDirectory = appContext.appDirectory, _distDirectory = appContext.distDirectory, _serverConfigFile = appContext.serverConfigFile;
+            _context.next = 8;
+            return hookRunners.beforeBuild({
+              // "null" bundlerConfigs
+              bundlerConfigs: undefined
+            });
+          case 8:
+            _context.next = 10;
+            return buildServerConfig({
+              appDirectory: _appDirectory,
+              distDirectory: _distDirectory,
+              configFile: _serverConfigFile
+            });
+          case 10:
+            _context.next = 12;
+            return generateRoutes(appContext);
+          case 12:
+            _context.next = 14;
+            return hookRunners.afterBuild({
+              // "null" stats
+              stats: undefined
+            });
+          case 14:
+            return _context.abrupt("return");
+          case 15:
+            resolvedConfig = _objectSpread(_objectSpread({}, resolvedConfig), {}, {
+              cliOptions: options
+            });
+            ResolvedConfigContext.set(resolvedConfig);
+            distDirectory = appContext.distDirectory, appDirectory = appContext.appDirectory, serverConfigFile = appContext.serverConfigFile;
+            _context.next = 20;
+            return buildServerConfig({
+              appDirectory: appDirectory,
+              distDirectory: distDirectory,
+              configFile: serverConfigFile
+            });
+          case 20:
+            _context.prev = 20;
+            logger.info('Create a production build...\n');
+            _context.next = 24;
+            return (_appContext$builder = appContext.builder) === null || _appContext$builder === void 0 ? void 0 : _appContext$builder.build();
+          case 24:
+            _context.next = 30;
+            break;
+          case 26:
+            _context.prev = 26;
+            _context.t0 = _context["catch"](20);
+            printBuildError(_context.t0);
+            // eslint-disable-next-line no-process-exit
+            process.exit(1);
+          case 30:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[20, 26]]);
+  }));
+  return function build(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,26 @@
+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,124 @@
+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 } from '@modern-js/utils';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { printInstructions } from "../utils/printInstructions";
+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, _appContext$builder, 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 = 20;
+              break;
+            }
+            _context2.next = 19;
+            return (_appContext$builder = appContext.builder) === null || _appContext$builder === void 0 ? void 0 : _appContext$builder.createCompiler();
+          case 19:
+            compiler = _context2.sent;
+          case 20:
+            _context2.next = 22;
+            return generateRoutes(appContext);
+          case 22:
+            _context2.next = 24;
+            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 24:
+            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...\n");
+                        } else {
+                          printInstructions(hookRunners, appContext, userConfig);
+                        }
+                      case 3:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+              return function (_x3) {
+                return _ref2.apply(this, arguments);
+              };
+            }());
+          case 26:
+          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";

package/dist/js/treeshaking/commands/inspect.js

@@ -0,0 +1,29 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { join } from 'path';
+export var inspect = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(api, options) {
+    var _appContext$builder;
+    var appContext;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            appContext = api.useAppContext();
+            return _context.abrupt("return", (_appContext$builder = appContext.builder) === null || _appContext$builder === void 0 ? void 0 : _appContext$builder.inspectConfig({
+              env: options.env,
+              verbose: options.verbose,
+              outputPath: join(appContext === null || appContext === void 0 ? void 0 : appContext.builder.context.distPath, options.output),
+              writeToDisk: true
+            }));
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return function inspect(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/commands/start.js

@@ -0,0 +1,69 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { logger, chalk, isApiOnly } from '@modern-js/utils';
+import server from '@modern-js/prod-server';
+import { printInstructions } from "../utils/printInstructions";
+import { injectDataLoaderPlugin } from "../utils/createServer";
+export var start = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(api) {
+    var _userConfig$source;
+    var appContext, userConfig, hookRunners, appDirectory, port, serverConfigFile, apiOnly, app;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            appContext = api.useAppContext();
+            userConfig = api.useResolvedConfigContext();
+            hookRunners = api.useHookRunners();
+            appDirectory = appContext.appDirectory, port = appContext.port, serverConfigFile = appContext.serverConfigFile;
+            logger.log(chalk.cyan("Starting the modern server..."));
+            _context2.next = 7;
+            return isApiOnly(appContext.appDirectory, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig$source = userConfig.source) === null || _userConfig$source === void 0 ? void 0 : _userConfig$source.entriesDir);
+          case 7:
+            apiOnly = _context2.sent;
+            _context2.next = 10;
+            return server({
+              pwd: appDirectory,
+              config: userConfig,
+              serverConfigFile: serverConfigFile,
+              internalPlugins: injectDataLoaderPlugin(appContext.serverInternalPlugins),
+              apiOnly: apiOnly
+            });
+          case 10:
+            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:
+                        _context.next = 4;
+                        return printInstructions(hookRunners, appContext, userConfig);
+                      case 4:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+              return function (_x2) {
+                return _ref2.apply(this, arguments);
+              };
+            }());
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return function start(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/exports/server.js

@@ -0,0 +1 @@
+export { defineServerConfig as defineConfig } from "../utils/config";

package/dist/js/treeshaking/hooks.js

@@ -0,0 +1,21 @@
+import { createAsyncWaterfall, createAsyncWorkflow } from '@modern-js/plugin';
+export var beforeDev = createAsyncWorkflow();
+export var afterDev = createAsyncWorkflow();
+export var beforeCreateCompiler = createAsyncWorkflow();
+export var afterCreateCompiler = createAsyncWorkflow();
+export var beforePrintInstructions = createAsyncWaterfall();
+export var beforeBuild = createAsyncWorkflow();
+export var afterBuild = createAsyncWorkflow();
+export var beforeDeploy = createAsyncWorkflow();
+export var afterDeploy = createAsyncWorkflow();
+export var hooks = {
+  beforeDev: beforeDev,
+  afterDev: afterDev,
+  beforeCreateCompiler: beforeCreateCompiler,
+  afterCreateCompiler: afterCreateCompiler,
+  beforePrintInstructions: beforePrintInstructions,
+  beforeBuild: beforeBuild,
+  afterBuild: afterBuild,
+  beforeDeploy: beforeDeploy,
+  afterDeploy: afterDeploy
+};