@modern-js/module-tools 1.5.5 → 1.6.0-alpha.0

package/dist/js/node/features/build/constants.js

@@ -3,77 +3,125 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runTscWatchTitle = exports.runTscTitle = exports.runStyleCompilerTitle = exports.runBabelCompilerTitle = exports.clearFlag = exports.PACKAGE_MODES = exports.DEFAULT_PACKAGE_MODE = void 0;
-// Universal JS 的默认选择，三份构建产物，支持 Node.js，对现代浏览器有优化
-const universalJs = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking'
-}, {
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node'
-}, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
-}]; // Universal JS 的优化选择，两份构建产物，对现代浏览器无优化
+exports.unPresets = exports.unPresetWithTargetConfigs = exports.unPresetConfigs = exports.targets = exports.npmLibraryWithUmdPresetConfig = exports.npmLibraryPresetConfig = exports.npmComponentWithUmdPresetConfig = exports.npmComponentPresetConfig = exports.clearFlag = exports.buildingText = exports.buildSuccessText = exports.buildFailText = void 0;
 
-const universalJsLite = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking'
-}, {
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node',
-  copyDirs: ['modern']
-}]; // 纯前端代码的默认选择，两份构建产物
+var _utils = require("@modern-js/utils");
 
-const browserJs = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking',
-  copyDirs: ['node']
-}, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
-}]; // 纯前端代码的优化选择，单份构建产物，对现代浏览器无优化
+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; }
 
-const browserJsLite = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking',
-  copyDirs: ['modern', 'node']
-}]; // 纯 Node.js 代码的默认选择，两份构建产物
+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 clearFlag = '\x1Bc';
+exports.clearFlag = clearFlag;
 
-const nodeJs = [{
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node'
+const buildingText = _utils.chalk.blue('Building...');
+
+exports.buildingText = buildingText;
+
+const buildSuccessText = _utils.chalk.green('Build succeed');
+
+exports.buildSuccessText = buildSuccessText;
+
+const buildFailText = _utils.chalk.red('Build Failed:');
+
+exports.buildFailText = buildFailText;
+const targets = ['es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext'];
+exports.targets = targets;
+const npmLibraryPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './es'
 }, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
+  buildType: 'bundle',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
 }];
-const DEFAULT_PACKAGE_MODE = 'universal-js';
-exports.DEFAULT_PACKAGE_MODE = DEFAULT_PACKAGE_MODE;
-const PACKAGE_MODES = {
-  'universal-js': universalJs,
-  'universal-js-lite': universalJsLite,
-  'browser-js': browserJs,
-  'browser-js-lite': browserJsLite,
-  'node-js': nodeJs
+exports.npmLibraryPresetConfig = npmLibraryPresetConfig;
+const npmLibraryWithUmdPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './es'
+}, {
+  format: 'umd',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './umd'
+}, {
+  buildType: 'bundle',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmLibraryWithUmdPresetConfig = npmLibraryWithUmdPresetConfig;
+const npmComponentPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './es'
+}, {
+  buildType: 'bundleless',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmComponentPresetConfig = npmComponentPresetConfig;
+const npmComponentWithUmdPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './es'
+}, {
+  format: 'umd',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './umd'
+}, {
+  buildType: 'bundleless',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmComponentWithUmdPresetConfig = npmComponentWithUmdPresetConfig;
+const unPresetConfigs = {
+  'npm-library': npmLibraryPresetConfig,
+  'npm-library-with-umd': npmLibraryWithUmdPresetConfig,
+  'npm-component': npmComponentPresetConfig,
+  'npm-component-with-umd': npmComponentWithUmdPresetConfig
 };
-exports.PACKAGE_MODES = PACKAGE_MODES;
-const runBabelCompilerTitle = 'Run babel compiler code log';
-exports.runBabelCompilerTitle = runBabelCompilerTitle;
-const runTscWatchTitle = 'Run `tsc -w` log';
-exports.runTscWatchTitle = runTscWatchTitle;
-const runTscTitle = 'Run `tsc` log';
-exports.runTscTitle = runTscTitle;
-const runStyleCompilerTitle = 'Run style compiler code log';
-exports.runStyleCompilerTitle = runStyleCompilerTitle;
-const clearFlag = '\x1Bc';
-exports.clearFlag = clearFlag;
+exports.unPresetConfigs = unPresetConfigs;
+const unPresets = Object.keys(unPresetConfigs);
+exports.unPresets = unPresets;
+const unPresetWithTargetConfigs = unPresets.reduce((o, presetStr) => {
+  const rets = targets.map(target => [`${presetStr}-${target}`.toLowerCase(), unPresetConfigs[presetStr].map(config => {
+    return _objectSpread(_objectSpread({}, config), {}, {
+      target
+    });
+  })]);
+  return _objectSpread(_objectSpread({}, o), Object.fromEntries(rets));
+}, {});
+exports.unPresetWithTargetConfigs = unPresetWithTargetConfigs;

package/dist/js/node/features/build/error.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.padSpaceWith = exports.isInternalError = exports.isExecaError = exports.ModuleBuildError = exports.InternalDTSError = exports.InternalBuildError = void 0;
+
+var _utils = require("@modern-js/utils");
+
+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 padSpaceWith = (str, targetL, opts = {}) => {
+  const {
+    endStr = '|',
+    style
+  } = opts;
+  const l = str.length;
+  const endStrL = endStr.length;
+  const resetL = targetL - l - endStrL; // str is 'aaa', targetL is 4, result is 'aaa|'
+
+  if (resetL === 0) {
+    return (style ? style(str) : str) + endStr;
+  } // str is 'aaa', targetL is 5, result is 'aaa |'
+
+
+  if (resetL > 0) {
+    const padStr = str.padEnd(targetL - 1, ' ');
+
+    if (style) {
+      return style(str) + padStr.replace(str, '') + endStr;
+    }
+
+    return padStr + endStr;
+  }
+
+  return str;
+};
+
+exports.padSpaceWith = padSpaceWith;
+
+class InternalBuildError extends Error {
+  constructor(e, opts) {
+    super(e.message);
+
+    _defineProperty(this, "buildType", void 0);
+
+    _defineProperty(this, "target", void 0);
+
+    _defineProperty(this, "format", void 0);
+
+    _defineProperty(this, "e", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.e = e;
+    this.buildType = opts.buildType;
+    this.target = opts.target;
+    this.format = opts.format;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      e,
+      buildType,
+      target,
+      format
+    } = this;
+    const textL = 25;
+    const title = `│ ${padSpaceWith(`${buildType} failed:`, textL - 2, {
+      style: _utils.chalk.red.underline,
+      endStr: '│'
+    })}`;
+    const formatMsg = padSpaceWith(`│  - format is "${format}"`, textL, {
+      endStr: '│'
+    });
+    const targetMsg = padSpaceWith(`│  - target is "${target}"`, textL, {
+      endStr: '│'
+    });
+    const startLine = padSpaceWith('╭'.padEnd(textL - 1, '─'), textL, {
+      endStr: '╮'
+    });
+    const endLine = padSpaceWith('╰'.padEnd(textL - 1, '─'), textL, {
+      endStr: '╯'
+    });
+    msgs.push(startLine, title, formatMsg, targetMsg, endLine, _utils.chalk.blue.bold.underline(`\nDetailed Information: `));
+    msgs.push(e.toString());
+    msgs.push(e.stack || '');
+    return msgs;
+  }
+
+}
+
+exports.InternalBuildError = InternalBuildError;
+
+class InternalDTSError extends Error {
+  constructor(e, opts) {
+    super(e.message);
+
+    _defineProperty(this, "buildType", void 0);
+
+    _defineProperty(this, "e", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.e = e;
+    this.buildType = opts.buildType;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      e,
+      buildType
+    } = this;
+    msgs.push(_utils.chalk.red.bold(`${buildType} DTS failed:`));
+
+    if (isExecaError(e)) {
+      /**
+       * `shortMeessage` content like:
+       * 'Command failed with exit code 2: /Users/github/modern.js/playground/module/node_modules/.bin/tsc -p /Users/github/modern.js/playground/module/node_modules/tsconfig.temp.json --pretty'
+       * Don`t need it.
+       */
+      if (e.stack) {
+        var _e$stack;
+
+        msgs.push((_e$stack = e.stack) === null || _e$stack === void 0 ? void 0 : _e$stack.replace(`${e.name}: ${e.shortMessage}`, ''));
+      }
+    } else {
+      msgs.push(e.stack);
+    }
+
+    return msgs;
+  }
+
+}
+
+exports.InternalDTSError = InternalDTSError;
+
+class ModuleBuildError extends Error {
+  constructor(e) {
+    super(`\n\n${e}`);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = 'ModuleBuildError';
+  }
+
+}
+
+exports.ModuleBuildError = ModuleBuildError;
+
+const isInternalError = e => {
+  if (e instanceof InternalBuildError || e instanceof InternalDTSError) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isInternalError = isInternalError;
+
+const isExecaError = e => {
+  if (e.stdout) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isExecaError = isExecaError;

package/dist/js/node/features/build/index.js

@@ -3,33 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.build = void 0;
+exports.buildInNormalMode = exports.build = void 0;
 
 var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
+var _readline = require("../../utils/readline");
+
+var _normalize = require("./normalize");
+
+var _constants = require("./constants");
+
+var _error = require("./error");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const buildFeature = _utils.Import.lazy('./build', require);
+const bundle = _utils.Import.lazy('./bundle', require);
 
-const buildWatchFeature = _utils.Import.lazy('./build-watch', require);
+const bundleless = _utils.Import.lazy('./bundleless', require);
 
 const bp = _utils.Import.lazy('./build-platform', require);
 
-const build = async (api, config, modernConfig) => {
+const checkPlatformAndRunBuild = async (platform, options) => {
   const {
-    appDirectory,
-    enableWatchMode,
-    platform,
-    clear = true,
+    api,
     isTsProject
-  } = config;
-  const {
-    output: {
-      path: outputPath = 'dist'
-    }
-  } = modernConfig; // TODO: maybe need watch mode in build platform
+  } = options;
 
   if (typeof platform === 'boolean' && platform) {
     if (process.env.RUN_PLATFORM) {
@@ -39,7 +39,9 @@ const build = async (api, config, modernConfig) => {
       });
     }
 
-    return;
+    return {
+      exit: true
+    };
   }
 
   if (typeof platform === 'string') {
@@ -50,17 +52,88 @@ const build = async (api, config, modernConfig) => {
       });
     }
 
+    return {
+      exit: true
+    };
+  }
+
+  return {
+    exit: false
+  };
+};
+
+const buildInNormalMode = async buildTasks => {
+  console.info(_utils.chalk.blue.bold(_constants.buildingText));
+
+  try {
+    // eslint-disable-next-line no-console
+    console.time(_constants.buildSuccessText);
+    await Promise.all(buildTasks);
+
+    _readline.ReadlineUtils.clearPrevLine(process.stdout); // eslint-disable-next-line no-console
+
+
+    console.timeEnd(_constants.buildSuccessText);
+  } catch (e) {
+    _readline.ReadlineUtils.clearPrevLine(process.stdout);
+
+    if ((0, _error.isInternalError)(e)) {
+      throw new _error.ModuleBuildError(e);
+    } else {
+      throw e;
+    }
+  }
+};
+
+exports.buildInNormalMode = buildInNormalMode;
+
+const build = async (api, config) => {
+  const {
+    platform,
+    clear = true,
+    isTsProject
+  } = config;
+  const {
+    appDirectory
+  } = api.useAppContext();
+  const modernConfig = api.useResolvedConfigContext();
+  const {
+    output: {
+      path: outputPath = 'dist'
+    }
+  } = modernConfig; // build platform
+
+  const platformBuildRet = await checkPlatformAndRunBuild(platform, {
+    api,
+    isTsProject
+  });
+
+  if (platformBuildRet.exit) {
     return;
   }
 
   if (clear) {
     _utils.fs.removeSync(_path.default.join(appDirectory, outputPath));
-  }
+  } // should normalize module tool config here, ensure the same config for build
+
+
+  const normalizedModuleConfig = (0, _normalize.normalizeModuleConfig)({
+    buildFeatOption: config,
+    api
+  });
+  const buildTasks = normalizedModuleConfig.map(moduleConfig => {
+    if (moduleConfig.buildType === 'bundle') {
+      return bundle.build(api, moduleConfig);
+    } else {
+      return bundleless.build(api, moduleConfig, config);
+    }
+  });
 
-  if (enableWatchMode) {
-    await buildWatchFeature.buildInWatchMode(api, config, modernConfig);
+  if (config.enableWatchMode) {
+    console.info(_utils.chalk.blue.underline('start build in watch mode...\n'));
+    await Promise.all(buildTasks);
   } else {
-    await buildFeature.buildSourceCode(api, config, modernConfig);
+    await buildInNormalMode(buildTasks);
   }
 };
 

package/dist/js/node/features/build/legacy-constants.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PACKAGE_MODES = exports.DEFAULT_PACKAGE_MODE = void 0;
+// Universal JS 的默认选择，三份构建产物，支持 Node.js，对现代浏览器有优化
+const universalJs = [{
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/treeshaking',
+  bundlelessOptions: {
+    style: {
+      compileMode: 'only-source-code'
+    }
+  }
+}, {
+  format: 'cjs',
+  target: 'es6',
+  outputPath: './js/node'
+}, {
+  format: 'esm',
+  target: 'es6',
+  outputPath: './js/modern'
+}]; // Universal JS 的优化选择，两份构建产物，对现代浏览器无优化
+
+const universalJsLite = [{
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/treeshaking',
+  bundlelessOptions: {
+    style: {
+      compileMode: 'only-source-code'
+    }
+  }
+}, {
+  format: 'cjs',
+  target: 'es6',
+  outputPath: './js/node'
+}, {
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/modern'
+}]; // 纯前端代码的默认选择，两份构建产物
+
+const browserJs = [{
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/treeshaking',
+  bundlelessOptions: {
+    style: {
+      compileMode: 'only-source-code'
+    }
+  }
+}, {
+  format: 'esm',
+  target: 'es6',
+  outputPath: './js/node'
+}, {
+  format: 'esm',
+  target: 'es6',
+  outputPath: './js/modern'
+}]; // 纯前端代码的优化选择，单份构建产物，对现代浏览器无优化
+
+const browserJsLite = [{
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/treeshaking',
+  bundlelessOptions: {
+    style: {
+      compileMode: 'only-source-code'
+    }
+  }
+}, {
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/node'
+}, {
+  format: 'esm',
+  target: 'es5',
+  outputPath: './js/modern'
+}]; // 纯 Node.js 代码的默认选择，两份构建产物
+
+const nodeJs = [{
+  format: 'cjs',
+  target: 'es6',
+  outputPath: './js/node',
+  bundlelessOptions: {
+    style: {
+      compileMode: 'only-source-code'
+    }
+  }
+}, {
+  format: 'esm',
+  target: 'es6',
+  outputPath: './js/modern'
+}];
+const DEFAULT_PACKAGE_MODE = 'universal-js';
+exports.DEFAULT_PACKAGE_MODE = DEFAULT_PACKAGE_MODE;
+const PACKAGE_MODES = {
+  'universal-js': universalJs,
+  'universal-js-lite': universalJsLite,
+  'browser-js': browserJs,
+  'browser-js-lite': browserJsLite,
+  'node-js': nodeJs
+};
+exports.PACKAGE_MODES = PACKAGE_MODES;