@modern-js/app-tools 1.0.0-alpha.3

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

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dev = void 0;
+
+var _webpack = require("@modern-js/webpack");
+
+var _utils = require("@modern-js/utils");
+
+var _core = require("@modern-js/core");
+
+var _createCompiler = require("../utils/createCompiler");
+
+var _createServer = require("../utils/createServer");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 () => {
+  /* eslint-disable react-hooks/rules-of-hooks */
+  const {
+    value: appContext
+  } = (0, _core.useAppContext)();
+  const {
+    value: userConfig
+  } = (0, _core.useResolvedConfigContext)();
+  /* eslint-enable react-hooks/rules-of-hooks */
+
+  const {
+    appDirectory,
+    distDirectory,
+    port
+  } = appContext;
+
+  _utils.fs.emptyDirSync(distDirectory);
+
+  await (0, _core.mountHook)().beforeDev();
+  const webpackConfigs = [(0, _utils.isSSR)(userConfig) && (0, _webpack.getWebpackConfig)(_webpack.WebpackConfigTarget.NODE), (0, _webpack.getWebpackConfig)(_webpack.WebpackConfigTarget.CLIENT)].filter(Boolean);
+  const compiler = await (0, _createCompiler.createCompiler)({
+    webpackConfigs,
+    userConfig,
+    appContext
+  });
+  const app = await (0, _createServer.createServer)({
+    dev: _objectSpread(_objectSpread({}, {
+      client: {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        port: port.toString(),
+        overlay: false,
+        logging: 'none',
+        path: _utils.HMR_SOCK_PATH,
+        host: 'localhost'
+      },
+      dev: {
+        writeToDisk: file => !file.includes('.hot-update.')
+      },
+      hot: true,
+      liveReload: true,
+      port
+    }), userConfig.tools.devServer),
+    compiler,
+    pwd: appDirectory,
+    config: userConfig,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+  });
+  app.listen(port, err => {
+    if (err) {
+      throw err;
+    }
+
+    (0, _utils.clearConsole)();
+
+    _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/start.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.start = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _core = require("@modern-js/core");
+
+var _server = _interopRequireDefault(require("@modern-js/server"));
+
+var _printInstructions = require("../utils/printInstructions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const start = async () => {
+  /* eslint-disable react-hooks/rules-of-hooks */
+  const {
+    value: appContext
+  } = (0, _core.useAppContext)();
+  const {
+    value: userConfig
+  } = (0, _core.useResolvedConfigContext)();
+  /* eslint-enable react-hooks/rules-of-hooks */
+
+  const {
+    appDirectory,
+    port
+  } = appContext;
+
+  _utils.logger.log(_utils.chalk.cyan(`Starting the modern server...`));
+
+  const app = await (0, _server.default)({
+    pwd: appDirectory,
+    config: userConfig,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    await (0, _printInstructions.printInstructions)(appContext);
+  });
+};
+
+exports.start = start;

package/dist/js/node/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "defineConfig", {
+  enumerable: true,
+  get: function () {
+    return _core.defineConfig;
+  }
+});
+
+var _core = require("@modern-js/core");
+
+var _lifecycle = require("./lifecycle");
+
+var _locale = require("./locale");
+
+var _language = require("./utils/language");
+
+var _start = require("./commands/start");
+
+var _dev = require("./commands/dev");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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; }
+
+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; }
+
+// eslint-disable-next-line react-hooks/rules-of-hooks
+(0, _core.usePlugins)([require.resolve('@modern-js/plugin-analyze/cli'), require.resolve('@modern-js/plugin-fast-refresh/cli'), require.resolve('@modern-js/plugin-polyfill/cli')]);
+
+var _default = (0, _core.createPlugin)(() => {
+  const locale = (0, _language.getLocaleLanguage)();
+
+  _locale.i18n.changeLanguage({
+    locale
+  });
+
+  (0, _lifecycle.lifecycle)();
+  return {
+    commands({
+      program
+    }) {
+      program.command('dev').usage('[options]').description(_locale.i18n.t(_locale.localeKeys.command.dev.describe)).option('-c --config <config>', _locale.i18n.t(_locale.localeKeys.command.dev.config)).action(async () => {
+        await (0, _dev.dev)();
+      });
+      program.command('build').usage('[options]').description(_locale.i18n.t(_locale.localeKeys.command.build.describe)).action(async () => {
+        const {
+          build
+        } = await Promise.resolve().then(() => _interopRequireWildcard(require("./commands/build")));
+        await build();
+      });
+      program.command('start').usage('[options]').description(_locale.i18n.t(_locale.localeKeys.command.start.describe)).action(async () => {
+        await (0, _start.start)();
+      });
+      program.command('new').usage('[options]').description(_locale.i18n.t(_locale.localeKeys.command.new.describe)).option('-d, --debug', _locale.i18n.t(_locale.localeKeys.command.new.debug), false).option('-c, --config <config>', _locale.i18n.t(_locale.localeKeys.command.new.config)).option('--dist-tag <tag>', _locale.i18n.t(_locale.localeKeys.command.new.distTag)).option('--registry', _locale.i18n.t(_locale.localeKeys.command.new.registry)).action(async options => {
+        const {
+          MWANewAction
+        } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/new-action')));
+        await MWANewAction(_objectSpread(_objectSpread({}, options), {}, {
+          locale
+        }));
+      });
+    },
+
+    async fileChange() {
+      // restart cli.
+      const shouldRestart = await _core.cli.restart();
+
+      if (shouldRestart) {
+        await (0, _dev.dev)();
+      }
+    }
+
+  };
+}, {
+  post: ['@modern-js/plugin-analyze', '@modern-js/plugin-fast-refresh', '@modern-js/plugin-ssr', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-polyfill']
+});
+
+exports.default = _default;

package/dist/js/node/lifecycle.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lifecycle = exports.beforePrintInstructions = exports.beforeDev = exports.beforeCreateCompiler = exports.beforeBuild = exports.afterDev = exports.afterCreateCompiler = exports.afterBuild = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+var _core = require("@modern-js/core");
+
+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 lifecycle = () => {
+  (0, _core.registerHook)({
+    beforeDev,
+    afterDev,
+    beforeCreateCompiler,
+    afterCreateCompiler,
+    beforePrintInstructions,
+    beforeBuild,
+    afterBuild
+  });
+};
+
+exports.lifecycle = lifecycle;

package/dist/js/node/locale/en.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EN_LOCALE = void 0;
+const EN_LOCALE = {
+  command: {
+    dev: {
+      describe: 'start dev server',
+      config: 'specify config file'
+    },
+    build: {
+      describe: 'build application'
+    },
+    start: {
+      describe: 'start server'
+    },
+    new: {
+      describe: 'generator runner for MWA project',
+      debug: 'using debug mode to log something',
+      config: 'set default generator config(json string)',
+      distTag: `use specified tag version for it's generator`,
+      registry: 'set npm registry url to run npm command'
+    }
+  }
+};
+exports.EN_LOCALE = EN_LOCALE;

package/dist/js/node/locale/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.localeKeys = exports.i18n = void 0;
+
+var _pluginI18n = require("@modern-js/plugin-i18n");
+
+var _zh = require("./zh");
+
+var _en = require("./en");
+
+const i18n = new _pluginI18n.I18n();
+exports.i18n = i18n;
+const localeKeys = i18n.init('zh', {
+  zh: _zh.ZH_LOCALE,
+  en: _en.EN_LOCALE
+});
+exports.localeKeys = localeKeys;

package/dist/js/node/locale/zh.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZH_LOCALE = void 0;
+const ZH_LOCALE = {
+  command: {
+    dev: {
+      describe: '本地开发命令',
+      config: '制定配置文件路径'
+    },
+    build: {
+      describe: '构建应用命令'
+    },
+    start: {
+      describe: '应用启动命令'
+    },
+    new: {
+      describe: 'MWA 项目中中执行生成器',
+      debug: '开启 Debug 模式，打印调试日志信息',
+      config: '生成器运行默认配置(JSON 字符串)',
+      distTag: '生成器使用特殊的 npm Tag 版本',
+      registry: '生成器运行过程中定制 npm Registry'
+    }
+  }
+};
+exports.ZH_LOCALE = ZH_LOCALE;

package/dist/js/node/utils/createCompiler.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCompiler = void 0;
+
+var _webpack = _interopRequireDefault(require("webpack"));
+
+var _core = require("@modern-js/core");
+
+var _utils = require("@modern-js/utils");
+
+var _printInstructions = require("./printInstructions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const prettyTime = stats => {
+  var _stats$children;
+
+  return Math.max(...(((_stats$children = stats.children) === null || _stats$children === void 0 ? void 0 : _stats$children.map(child => child.time || 0)) || []));
+};
+
+const createCompiler = async ({
+  webpackConfigs,
+  // TODO: params
+  userConfig: _userConfig,
+  appContext
+}) => {
+  try {
+    await (0, _core.mountHook)().beforeCreateCompiler({
+      webpackConfigs
+    });
+    const compiler = (0, _webpack.default)(webpackConfigs);
+    await (0, _core.mountHook)().afterCreateCompiler({
+      compiler
+    });
+    let isFirstCompile = true;
+    compiler.hooks.invalid.tap('invalid', () => {
+      (0, _utils.clearConsole)();
+
+      _utils.logger.log('Compiling...');
+    });
+    compiler.hooks.done.tap('done', async stats => {
+      (0, _utils.clearConsole)();
+      const statsData = stats.toJson({
+        all: false,
+        warnings: true,
+        errors: true,
+        timings: true
+      });
+      const {
+        errors,
+        warnings
+      } = (0, _utils.formatWebpackMessages)(statsData);
+
+      if (errors.length) {
+        _utils.logger.log(_utils.chalk.red(`Failed to compile.\n`));
+
+        _utils.logger.log(errors.join('\n\n'));
+
+        _utils.logger.log();
+      } else if (process.stdout.isTTY || isFirstCompile) {
+        await (0, _core.mountHook)().afterDev();
+
+        if (warnings.length) {
+          _utils.logger.log(_utils.chalk.yellow(`Compiled with warnings.\n`));
+
+          _utils.logger.log(warnings.join('\n\n'));
+
+          _utils.logger.log();
+        } else {
+          _utils.logger.log(_utils.chalk.green(`Compiled successfully in ${prettyTime(statsData)} ms.\n`));
+        }
+
+        await (0, _printInstructions.printInstructions)(appContext);
+      } // eslint-disable-next-line require-atomic-updates
+
+
+      isFirstCompile = false;
+    });
+    return compiler;
+  } catch (err) {
+    _utils.logger.log(_utils.chalk.red(`Failed to compile.`));
+
+    _utils.logger.log();
+
+    _utils.logger.log(err); // eslint-disable-next-line no-process-exit
+
+
+    process.exit(1);
+  }
+};
+
+exports.createCompiler = createCompiler;

package/dist/js/node/utils/createServer.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createServer = void 0;
+
+var _server = require("@modern-js/server");
+
+let server;
+
+const createServer = async options => {
+  if (server) {
+    await server.close();
+  } // eslint-disable-next-line require-atomic-updates
+
+
+  server = new _server.Server(options);
+  const app = await server.init();
+  return app;
+};
+
+exports.createServer = createServer;

package/dist/js/node/utils/language.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocaleLanguage = getLocaleLanguage;
+
+var _i18nCliLanguageDetector = require("@modern-js/i18n-cli-language-detector");
+
+function getLocaleLanguage() {
+  const detector = new _i18nCliLanguageDetector.I18CLILanguageDetector();
+  return detector.detect();
+}

package/dist/js/node/utils/printInstructions.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.printInstructions = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _core = require("@modern-js/core");
+
+const printInstructions = async appContext => {
+  let message = (0, _utils.prettyInstructions)(appContext);
+
+  if ((0, _utils.isDev)()) {
+    message += `\n${_utils.chalk.cyanBright([`Note that the development build is not optimized.`, `To create a production build, use yarn build.`].join('\n'))}`;
+  } // call beforePrintInstructions hook.
+
+
+  const {
+    instructions
+  } = await (0, _core.mountHook)().beforePrintInstructions({
+    instructions: message
+  });
+
+  _utils.logger.log(instructions);
+};
+
+exports.printInstructions = printInstructions;

package/dist/types/commands/build.d.ts

@@ -0,0 +1 @@
+export declare const build: () => Promise<never>;

package/dist/types/commands/dev.d.ts

@@ -0,0 +1 @@
+export declare const dev: () => Promise<void>;

package/dist/types/commands/index.d.ts

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

package/dist/types/commands/start.d.ts

@@ -0,0 +1 @@
+export declare const start: () => Promise<void>;

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from '@modern-js/core';
+export { defineConfig };
+
+declare const _default: import("@modern-js/plugin").AsyncPlugin<Partial<import("@modern-js/plugin").Progresses2Threads<{
+  config: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+  commands: import("@modern-js/plugin").AsyncWorkflow<{
+    program: import("commander").Command;
+  }, void>;
+  watchFiles: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+  fileChange: import("@modern-js/plugin").AsyncWorkflow<{
+    filename: string;
+  }, void>;
+  beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+} & import("@modern-js/plugin").ClearDraftProgress<import("@modern-js/core").Hooks>>>>;
+
+export default _default;

package/dist/types/lifecycle.d.ts

@@ -0,0 +1,17 @@
+import type { Compiler, Configuration, MultiCompiler } from '@modern-js/types';
+export declare const beforeDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
+export declare const afterDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
+export declare const beforeCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
+  webpackConfigs: Configuration[];
+}, unknown>;
+export declare const afterCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
+  compiler: Compiler | MultiCompiler | undefined;
+}, unknown>;
+export declare const beforePrintInstructions: import("@modern-js/plugin").AsyncWaterfall<{
+  instructions: string;
+}>;
+export declare const beforeBuild: import("@modern-js/plugin").AsyncWorkflow<{
+  webpackConfigs: Configuration[];
+}, unknown>;
+export declare const afterBuild: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
+export declare const lifecycle: () => void;

package/dist/types/locale/en.d.ts

@@ -0,0 +1,21 @@
+export declare const EN_LOCALE: {
+  command: {
+    dev: {
+      describe: string;
+      config: string;
+    };
+    build: {
+      describe: string;
+    };
+    start: {
+      describe: string;
+    };
+    new: {
+      describe: string;
+      debug: string;
+      config: string;
+      distTag: string;
+      registry: string;
+    };
+  };
+};

package/dist/types/locale/index.d.ts

@@ -0,0 +1,44 @@
+import { I18n } from '@modern-js/plugin-i18n';
+declare const i18n: I18n;
+declare const localeKeys: {
+  command: {
+    dev: {
+      describe: string;
+      config: string;
+    };
+    build: {
+      describe: string;
+    };
+    start: {
+      describe: string;
+    };
+    new: {
+      describe: string;
+      debug: string;
+      config: string;
+      distTag: string;
+      registry: string;
+    };
+  };
+} | {
+  command: {
+    dev: {
+      describe: string;
+      config: string;
+    };
+    build: {
+      describe: string;
+    };
+    start: {
+      describe: string;
+    };
+    new: {
+      describe: string;
+      debug: string;
+      config: string;
+      distTag: string;
+      registry: string;
+    };
+  };
+};
+export { i18n, localeKeys };