@modern-js/app-tools 2.53.0 → 2.53.1-alpha.1

package/dist/js/node/analyze/utils.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.walkDirectory = exports.isRouteComponentFile = exports.getDefaultImports = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const walkDirectory = dir => _fs.default.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = _path.default.join(dir, filename);
+
+  if (_fs.default.statSync(filePath).isDirectory()) {
+    return [...previous, ...walkDirectory(filePath)];
+  } else {
+    return [...previous, filePath];
+  }
+}, []);
+
+exports.walkDirectory = walkDirectory;
+
+const getDefaultImports = ({
+  entrypoint,
+  srcDirectory,
+  internalSrcAlias,
+  internalDirAlias,
+  internalDirectory
+}) => {
+  const {
+    entryName,
+    fileSystemRoutes,
+    customBootstrap,
+    entry
+  } = entrypoint;
+  const imports = [{
+    specifiers: [{
+      local: 'React'
+    }],
+    value: 'react'
+  }, {
+    specifiers: [{
+      local: 'ReactDOM'
+    }],
+    value: (0, _utils.isReact18)(_path.default.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
+  }, {
+    specifiers: [{
+      imported: 'createApp'
+    }, {
+      imported: 'bootstrap'
+    }],
+    value: '@modern-js/runtime'
+  }, customBootstrap && {
+    specifiers: [{
+      local: 'customBootstrap'
+    }],
+    value: (0, _utils.normalizeToPosixPath)(customBootstrap.replace(srcDirectory, internalSrcAlias))
+  }].filter(Boolean);
+
+  if (fileSystemRoutes) {
+    const route = {
+      specifiers: [{
+        imported: 'routes'
+      }],
+      value: (0, _utils.normalizeToPosixPath)(`${internalDirAlias}/${entryName}/${_constants.FILE_SYSTEM_ROUTES_FILE_NAME}`)
+    };
+
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{
+          local: 'App'
+        }],
+        value: (0, _utils.normalizeToPosixPath)(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+      });
+    } else {
+      route.initialize = 'const App = false;';
+    }
+
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{
+        local: 'App'
+      }],
+      value: (0, _utils.normalizeToPosixPath)(entry.replace(srcDirectory, internalSrcAlias))
+    });
+  }
+
+  return imports;
+};
+
+exports.getDefaultImports = getDefaultImports;
+
+const isRouteComponentFile = filePath => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+
+  if (['.js', '.jsx', '.ts', '.tsx'].includes(_path.default.extname(filePath))) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isRouteComponentFile = isRouteComponentFile;

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

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

package/dist/js/node/commands/deploy.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deploy = void 0;
+
+const deploy = async (api, options) => {
+  const hookRunners = api.useHookRunners();
+  await hookRunners.beforeDeploy(options);
+  await hookRunners.afterDeploy(options);
+};
+
+exports.deploy = deploy;

package/dist/js/node/commands/dev.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dev = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _core = require("@modern-js/core");
+
+var _createCompiler = require("../utils/createCompiler");
+
+var _createServer = require("../utils/createServer");
+
+var _routes = require("../utils/routes");
+
+var _printInstructions = require("../utils/printInstructions");
+
+var _getSpecifiedEntries = require("../utils/getSpecifiedEntries");
+
+var _config = require("../utils/config");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const dev = async (api, options) => {
+  let userConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  userConfig = _objectSpread(_objectSpread({}, userConfig), {}, {
+    cliOptions: options
+  });
+
+  _core.ResolvedConfigContext.set(userConfig);
+
+  const {
+    appDirectory,
+    distDirectory,
+    port,
+    apiOnly,
+    entrypoints,
+    serverConfigFile
+  } = appContext;
+  const checkedEntries = await (0, _getSpecifiedEntries.getSpecifiedEntries)(options.entry || false, entrypoints);
+  api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+    checkedEntries
+  }));
+  appContext.checkedEntries = checkedEntries;
+
+  _utils.fs.emptyDirSync(distDirectory);
+
+  await (0, _config.buildServerConfig)({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile,
+    options: {
+      esbuildOptions: {
+        watch: true
+      }
+    }
+  });
+  await hookRunners.beforeDev();
+  let compiler = null;
+
+  if (!apiOnly) {
+    const {
+      getWebpackConfig,
+      WebpackConfigTarget
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/webpack')));
+    const webpackConfigs = [(0, _utils.isSSR)(userConfig) && getWebpackConfig(WebpackConfigTarget.NODE, appContext, userConfig), getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, userConfig)].filter(Boolean);
+    compiler = await (0, _createCompiler.createCompiler)({
+      api,
+      webpackConfigs,
+      userConfig,
+      appContext
+    });
+  }
+
+  await (0, _routes.generateRoutes)(appContext);
+  const app = await (0, _createServer.createServer)({
+    dev: _objectSpread(_objectSpread({}, {
+      client: {
+        port: port.toString()
+      },
+      devMiddleware: {
+        writeToDisk: file => !file.includes('.hot-update.')
+      },
+      hot: true,
+      liveReload: true,
+      port,
+      https: userConfig.dev.https
+    }), userConfig.tools.devServer),
+    compiler,
+    pwd: appDirectory,
+    config: userConfig,
+    serverConfigFile,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    if (apiOnly) {
+      return (0, _printInstructions.printInstructions)(hookRunners, appContext, userConfig);
+    }
+
+    return _utils.logger.log(_utils.chalk.cyan(`Starting the development server...`));
+  });
+};
+
+exports.dev = dev;

package/dist/js/node/commands/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _dev = require("./dev");
+
+Object.keys(_dev).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dev[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dev[key];
+    }
+  });
+});
+
+var _build = require("./build");
+
+Object.keys(_build).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _build[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _build[key];
+    }
+  });
+});
+
+var _start = require("./start");
+
+Object.keys(_start).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _start[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _start[key];
+    }
+  });
+});

package/dist/js/node/commands/inspect.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.printInspectResult = exports.inspect = exports.getTagByWebpackTarget = exports.formatWebpackConfig = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _webpack = require("@modern-js/webpack");
+
+var _utils = require("@modern-js/utils");
+
+var _webpackChain = _interopRequireDefault(require("@modern-js/utils/webpack-chain"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const formatWebpackConfig = (config, verbose) => {
+  const stringify = _webpackChain.default.toString;
+  return `module.exports = ${stringify(config, {
+    verbose
+  })};`;
+};
+
+exports.formatWebpackConfig = formatWebpackConfig;
+
+const inspect = (api, options) => {
+  process.env.NODE_ENV = options.env;
+  const resolvedConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const outputFiles = [];
+  outputFiles.push(printInspectResult(_webpack.WebpackConfigTarget.CLIENT, appContext, resolvedConfig, options));
+
+  if (resolvedConfig.output.enableModernMode) {
+    outputFiles.push(printInspectResult(_webpack.WebpackConfigTarget.MODERN, appContext, resolvedConfig, options));
+  }
+
+  if ((0, _utils.isUseSSRBundle)(resolvedConfig)) {
+    outputFiles.push(printInspectResult(_webpack.WebpackConfigTarget.NODE, appContext, resolvedConfig, options));
+  }
+
+  _utils.logger.success('Inspect succeed, you can open following files to view the full webpack config: \n');
+
+  outputFiles.forEach(file => {
+    _utils.logger.log(`  - ${_utils.chalk.yellow(_path.default.relative(appContext.appDirectory, file))}`);
+  });
+
+  _utils.logger.log();
+};
+
+exports.inspect = inspect;
+
+const getTagByWebpackTarget = webpackTarget => {
+  switch (webpackTarget) {
+    case _webpack.WebpackConfigTarget.CLIENT:
+      return 'client';
+
+    case _webpack.WebpackConfigTarget.MODERN:
+      return 'modern';
+
+    case _webpack.WebpackConfigTarget.NODE:
+      return 'ssr';
+
+    default:
+      throw Error(`Unsupported webpack target: ${webpackTarget}`);
+  }
+};
+
+exports.getTagByWebpackTarget = getTagByWebpackTarget;
+
+const printInspectResult = (webpackTarget, appContext, resolvedConfig, options) => {
+  const webpackConfig = (0, _webpack.getWebpackConfig)(webpackTarget, appContext, resolvedConfig);
+  const {
+    output,
+    verbose,
+    console = true
+  } = options;
+  const outputPath = output ? _path.default.posix.join(appContext.distDirectory, output) : appContext.distDirectory;
+  const tag = getTagByWebpackTarget(webpackTarget);
+  const outputFile = `webpack.${tag}.inspect.js`;
+
+  const outputFilePath = _path.default.posix.join(outputPath, outputFile);
+
+  const rawWebpackConfig = formatWebpackConfig(webpackConfig, verbose);
+
+  _utils.fs.outputFileSync(outputFilePath, rawWebpackConfig);
+
+  if (console) {
+    _utils.logger.log(`
+webpack config for ${tag} build:
+${rawWebpackConfig}
+    `);
+  }
+
+  return outputFilePath;
+};
+
+exports.printInspectResult = printInspectResult;

package/dist/js/node/commands/start.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.start = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _prodServer = _interopRequireDefault(require("@modern-js/prod-server"));
+
+var _printInstructions = require("../utils/printInstructions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const start = async api => {
+  var _userConfig$source;
+
+  const appContext = api.useAppContext();
+  const userConfig = api.useResolvedConfigContext();
+  const hookRunners = api.useHookRunners();
+  const {
+    appDirectory,
+    port,
+    serverConfigFile
+  } = appContext;
+
+  _utils.logger.log(_utils.chalk.cyan(`Starting the modern server...`));
+
+  const apiOnly = await (0, _utils.isApiOnly)(appContext.appDirectory, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig$source = userConfig.source) === null || _userConfig$source === void 0 ? void 0 : _userConfig$source.entriesDir);
+  const app = await (0, _prodServer.default)({
+    pwd: appDirectory,
+    config: userConfig,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server),
+    serverConfigFile,
+    apiOnly
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    await (0, _printInstructions.printInstructions)(hookRunners, appContext, userConfig);
+  });
+};
+
+exports.start = start;

package/dist/js/node/exports/server.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "defineConfig", {
+  enumerable: true,
+  get: function () {
+    return _config.defineServerConfig;
+  }
+});
+
+var _config = require("../utils/config");

package/dist/js/node/hooks.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hooks = exports.beforePrintInstructions = exports.beforeDev = exports.beforeDeploy = exports.beforeCreateCompiler = exports.beforeBuild = exports.afterDev = exports.afterDeploy = exports.afterCreateCompiler = exports.afterBuild = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+const beforeDev = (0, _plugin.createAsyncWorkflow)();
+exports.beforeDev = beforeDev;
+const afterDev = (0, _plugin.createAsyncWorkflow)();
+exports.afterDev = afterDev;
+const beforeCreateCompiler = (0, _plugin.createAsyncWorkflow)();
+exports.beforeCreateCompiler = beforeCreateCompiler;
+const afterCreateCompiler = (0, _plugin.createAsyncWorkflow)();
+exports.afterCreateCompiler = afterCreateCompiler;
+const beforePrintInstructions = (0, _plugin.createAsyncWaterfall)();
+exports.beforePrintInstructions = beforePrintInstructions;
+const beforeBuild = (0, _plugin.createAsyncWorkflow)();
+exports.beforeBuild = beforeBuild;
+const afterBuild = (0, _plugin.createAsyncWorkflow)();
+exports.afterBuild = afterBuild;
+const beforeDeploy = (0, _plugin.createAsyncWorkflow)();
+exports.beforeDeploy = beforeDeploy;
+const afterDeploy = (0, _plugin.createAsyncWorkflow)();
+exports.afterDeploy = afterDeploy;
+const hooks = {
+  beforeDev,
+  afterDev,
+  beforeCreateCompiler,
+  afterCreateCompiler,
+  beforePrintInstructions,
+  beforeBuild,
+  afterBuild,
+  beforeDeploy,
+  afterDeploy
+};
+exports.hooks = hooks;