@modern-js/module-tools 1.5.8 → 1.6.1

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

@@ -1,21 +1,19 @@
 import path from 'path';
-import { Import, fs } from '@modern-js/utils';
-const buildFeature = Import.lazy('./build', require);
-const buildWatchFeature = Import.lazy('./build-watch', require);
+import { Import, fs, chalk } from '@modern-js/utils';
+import pMap from 'p-map';
+import { ReadlineUtils } from "../../utils/readline";
+import { normalizeModuleConfig } from "./normalize";
+import { buildingText, buildSuccessText } from "./constants";
+import { ModuleBuildError, isInternalError } from "./error";
+import { getAllDeps } from "./utils";
+const bundle = Import.lazy('./bundle', require);
+const bundleless = Import.lazy('./bundleless', require);
 const bp = Import.lazy('./build-platform', require);
-export const build = async (api, config, modernConfig) => {
+export 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) {
@@ -25,7 +23,9 @@ export const build = async (api, config, modernConfig) => {
       });
     }
 
-    return;
+    return {
+      exit: true
+    };
   }
 
   if (typeof platform === 'string') {
@@ -36,6 +36,66 @@ export const build = async (api, config, modernConfig) => {
       });
     }
 
+    return {
+      exit: true
+    };
+  }
+
+  return {
+    exit: false
+  };
+};
+export const runBuild = async (api, normalizedModuleConfig, config) => {
+  await pMap(normalizedModuleConfig, async moduleConfig => {
+    if (moduleConfig.buildType === 'bundle') {
+      await bundle.build(api, moduleConfig);
+    } else {
+      await bundleless.build(api, moduleConfig, config);
+    }
+  });
+};
+export const buildInNormalMode = async (api, normalizedModuleConfig, config) => {
+  console.info(chalk.blue.bold(buildingText));
+
+  try {
+    // eslint-disable-next-line no-console
+    console.time(buildSuccessText);
+    await runBuild(api, normalizedModuleConfig, config);
+    ReadlineUtils.clearPrevLine(process.stdout); // eslint-disable-next-line no-console
+
+    console.timeEnd(buildSuccessText);
+  } catch (e) {
+    ReadlineUtils.clearPrevLine(process.stdout);
+
+    if (isInternalError(e)) {
+      throw new ModuleBuildError(e);
+    } else {
+      throw e;
+    }
+  }
+};
+export 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;
   }
 
@@ -43,9 +103,18 @@ export const build = async (api, config, modernConfig) => {
     fs.removeSync(path.join(appDirectory, outputPath));
   }
 
-  if (enableWatchMode) {
-    await buildWatchFeature.buildInWatchMode(api, config, modernConfig);
+  const deps = getAllDeps(appDirectory); // should normalize module tool config here, ensure the same config for build
+
+  const normalizedModuleConfig = normalizeModuleConfig({
+    buildFeatOption: config,
+    api,
+    deps
+  });
+
+  if (config.enableWatchMode) {
+    console.info(chalk.blue.underline('start build in watch mode...\n'));
+    await runBuild(api, normalizedModuleConfig, config);
   } else {
-    await buildFeature.buildSourceCode(api, config, modernConfig);
+    await buildInNormalMode(api, normalizedModuleConfig, config);
   }
 };

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

@@ -0,0 +1,99 @@
+// 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'
+}];
+export const DEFAULT_PACKAGE_MODE = 'universal-js';
+export const PACKAGE_MODES = {
+  'universal-js': universalJs,
+  'universal-js-lite': universalJsLite,
+  'browser-js': browserJs,
+  'browser-js-lite': browserJsLite,
+  'node-js': nodeJs
+};

package/dist/js/modern/features/build/normalize.js

@@ -0,0 +1,301 @@
+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; }
+
+/* eslint-disable max-lines */
+import { Import, lodash } from '@modern-js/utils';
+import { mergeWith } from '@modern-js/utils/lodash';
+import { cliTsConfigDefaultValue } from "../../utils/constants";
+const constants = Import.lazy('./constants', require);
+const legacyConstants = Import.lazy('./legacy-constants', require);
+export const getNormalizeModuleConfigByPackageModeAndFileds = (api, buildFeatOption) => {
+  const {
+    output: {
+      packageMode,
+      packageFields,
+      disableTsChecker,
+      importStyle
+    }
+  } = api.useResolvedConfigContext();
+  let configs = [];
+
+  if (buildFeatOption.styleOnly) {
+    configs.push({
+      buildType: 'bundleless',
+      outputPath: './js/styles',
+      bundlelessOptions: {
+        sourceDir: './src',
+        style: {
+          compileMode: importStyle === 'source-code' ? 'only-source-code' : 'all'
+        }
+      }
+    });
+    configs.push({
+      buildType: 'bundleless',
+      outputPath: './styles',
+      bundlelessOptions: {
+        sourceDir: './styles',
+        style: {
+          compileMode: 'only-compiled-code'
+        }
+      }
+    });
+    return configs;
+  }
+
+  const commonConfig = {
+    buildType: 'bundleless',
+    bundlelessOptions: {
+      sourceDir: './src',
+      style: {
+        path: '../styles',
+        compileMode: false
+      },
+      static: {
+        path: '../styles'
+      }
+    },
+    outputPath: './'
+  };
+  commonConfig.tsconfig = getFinalTsconfig(commonConfig, buildFeatOption);
+
+  if (!packageFields || typeof packageFields === 'object' && Object.keys(packageFields).length === 0) {
+    const buildConfigs = legacyConstants.PACKAGE_MODES[packageMode || legacyConstants.DEFAULT_PACKAGE_MODE];
+    configs = buildConfigs.map(config => lodash.mergeWith({}, commonConfig, config));
+  } else {
+    const getConfigsByJsSyntaxType = (js, outputPath) => {
+      if (js === 'CJS+ES6') {
+        return lodash.mergeWith({}, commonConfig, {
+          format: 'cjs',
+          target: 'es6',
+          outputPath
+        });
+      } else if (js === 'ESM+ES5') {
+        return lodash.mergeWith({}, commonConfig, {
+          format: 'esm',
+          target: 'es5',
+          outputPath
+        });
+      }
+
+      return lodash.mergeWith({}, commonConfig, {
+        format: 'esm',
+        target: 'es6',
+        outputPath
+      });
+    };
+
+    if (!packageFields['jsnext:modern'] && !packageFields.main && !packageFields.module) {
+      throw new Error(`Unrecognized ${JSON.stringify(packageFields)} configuration, please use keys: 'modern, main, jupiter:modern' and use values: 'CJS+ES6, ESM+ES5, ESM+ES6'`);
+    } // The fields configured in packageFields correspond to the main, module, and jsnext:modern fields on package.json,
+    // and can also be used on package.json exports field.
+
+
+    if (packageFields['jsnext:modern']) {
+      configs.push(getConfigsByJsSyntaxType(packageFields['jsnext:modern'], 'js/modern'));
+    }
+
+    if (packageFields.main) {
+      configs.push(getConfigsByJsSyntaxType(packageFields.main, 'js/node'));
+    }
+
+    if (packageFields.module) {
+      configs.push(getConfigsByJsSyntaxType(packageFields.module, 'js/treeshaking'));
+    }
+  }
+
+  if (configs.length > 0) {
+    const firstConfig = configs[0];
+    firstConfig.bundlelessOptions = lodash.mergeWith({}, firstConfig.bundlelessOptions, {
+      style: {
+        compileMode: importStyle === 'source-code' ? 'only-source-code' : 'all'
+      }
+    });
+  } // [compatibe mode]: dts gen
+
+
+  if (buildFeatOption.legacyTsc && !disableTsChecker) {
+    configs.push({
+      buildType: 'bundleless',
+      outputPath: './types',
+      enableDts: true,
+      dtsOnly: true
+    });
+  }
+
+  configs.push({
+    buildType: 'bundleless',
+    outputPath: './styles',
+    bundlelessOptions: {
+      sourceDir: './styles',
+      style: {
+        compileMode: 'only-compiled-code'
+      }
+    }
+  });
+  return configs;
+};
+export const getFinalTsconfig = (config, buildFeatOption) => {
+  var _config$tsconfig;
+
+  // cli tsconfig option > buildPreset tsconfig option
+  // Since tsconfig configuration has default values,
+  // compare the two to see if the user is configured with cli tsconfig
+  if (buildFeatOption.tsconfigName !== cliTsConfigDefaultValue) {
+    return buildFeatOption.tsconfigName;
+  }
+
+  return (_config$tsconfig = config.tsconfig) !== null && _config$tsconfig !== void 0 ? _config$tsconfig : './tsconfig.json';
+};
+export const getFinalDts = (config, buildFeatOption) => {
+  var _config$enableDts;
+
+  // is js project, should return false
+  if (!buildFeatOption.isTsProject) {
+    return false;
+  } // when `build --dts`, then all build tasks`s enableDts is true
+
+
+  if (buildFeatOption.enableDtsGen) {
+    return true;
+  }
+
+  return (_config$enableDts = config.enableDts) !== null && _config$enableDts !== void 0 ? _config$enableDts : false;
+};
+export const getSourceMap = (config, buildType, api) => {
+  // TODO: remove
+  const {
+    output: {
+      disableSourceMap
+    }
+  } = api.useResolvedConfigContext();
+
+  if (disableSourceMap) {
+    return false;
+  }
+
+  if (config.sourceMap !== undefined) {
+    return config.sourceMap;
+  }
+
+  return buildType === 'bundle';
+};
+export const normalizeBuildConfig = (context, buildConfig, deps = []) => {
+  const {
+    buildFeatOption,
+    api
+  } = context;
+  const configArray = Array.isArray(buildConfig) ? buildConfig : [buildConfig];
+  const normalizedModule = configArray.map(config => {
+    var _config$format, _config$target, _bundleOptions$skipDe, _bundleOptions$minify, _bundleOptions$splitt, _config$outputPath, _config$dtsOnly;
+
+    const format = (_config$format = config.format) !== null && _config$format !== void 0 ? _config$format : 'cjs';
+    const target = (_config$target = config.target) !== null && _config$target !== void 0 ? _config$target : 'esnext';
+    const {
+      bundleOptions
+    } = config;
+    const skipDeps = (_bundleOptions$skipDe = bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.skipDeps) !== null && _bundleOptions$skipDe !== void 0 ? _bundleOptions$skipDe : true;
+    const externals = skipDeps === false ? (bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.externals) || [] : [...deps.map(dep => new RegExp(`^${dep}($|\\/|\\\\)`)), ...((bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.externals) || [])];
+
+    const normalizedBundleOption = _objectSpread(_objectSpread({}, bundleOptions), {}, {
+      entry: (bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.entry) || {
+        index: `src/index.${buildFeatOption.isTsProject ? 'ts' : 'js'}`
+      },
+      platform: (bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.platform) || 'node',
+      minify: (_bundleOptions$minify = bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.minify) !== null && _bundleOptions$minify !== void 0 ? _bundleOptions$minify : false,
+      externals,
+      splitting: (_bundleOptions$splitt = bundleOptions === null || bundleOptions === void 0 ? void 0 : bundleOptions.splitting) !== null && _bundleOptions$splitt !== void 0 ? _bundleOptions$splitt : false,
+      skipDeps
+    });
+
+    const normalizedBundlelessOptions = mergeWith({}, {
+      sourceDir: './src',
+      style: {
+        compileMode: 'all',
+        path: './'
+      },
+      static: {
+        path: './'
+      }
+    }, config.bundlelessOptions);
+    const watch = buildFeatOption.enableWatchMode || false;
+    const tsconfig = getFinalTsconfig(config, buildFeatOption);
+    const enableDts = getFinalDts(config, buildFeatOption);
+    const outputPath = (_config$outputPath = config.outputPath) !== null && _config$outputPath !== void 0 ? _config$outputPath : './';
+    const sourceMap = getSourceMap(config, config.buildType, api);
+    const dtsOnly = (_config$dtsOnly = config.dtsOnly) !== null && _config$dtsOnly !== void 0 ? _config$dtsOnly : false;
+    const commmonConfig = {
+      format,
+      target,
+      watch,
+      tsconfig,
+      enableDts,
+      outputPath,
+      dtsOnly,
+      sourceMap
+    };
+
+    if (!buildFeatOption.isTsProject && (dtsOnly || enableDts)) {
+      console.warn('[WARN] dtsOnly、enableDts 配置仅在 Ts 项目下生效');
+    } else if (buildFeatOption.isTsProject && dtsOnly && !enableDts) {
+      console.warn('[WARN] dtsOnly 配置仅在 enableDts 为 true 的时候生效. 请检查当前的 dtsOnly、enableDts 是否配置正确');
+    }
+
+    if (config.buildType === 'bundle') {
+      return _objectSpread(_objectSpread({}, commmonConfig), {}, {
+        buildType: 'bundle',
+        bundleOptions: normalizedBundleOption
+      });
+    } else {
+      return _objectSpread(_objectSpread({}, commmonConfig), {}, {
+        buildType: 'bundleless',
+        bundlelessOptions: normalizedBundlelessOptions
+      });
+    }
+  });
+  return normalizedModule;
+};
+export const normalizeModuleConfig = context => {
+  const {
+    buildFeatOption,
+    api,
+    deps
+  } = context;
+  const {
+    output: {
+      buildConfig,
+      buildPreset
+    }
+  } = api.useResolvedConfigContext(); // buildConfig is the most important.
+
+  if (buildConfig) {
+    return normalizeBuildConfig(context, buildConfig, deps);
+  } // buildPreset is the second important. It can be used when buildConfig is not defined.
+  // buildPreset -> buildConfig
+
+
+  if (buildPreset) {
+    const {
+      unPresetConfigs,
+      unPresetWithTargetConfigs
+    } = constants;
+
+    if (unPresetConfigs[buildPreset]) {
+      return normalizeBuildConfig(context, unPresetConfigs[buildPreset], deps);
+    } else if (unPresetWithTargetConfigs[buildPreset]) {
+      return normalizeBuildConfig(context, unPresetWithTargetConfigs[buildPreset], deps);
+    } // If the buildPreset is not found, then it is used 'npm-library'
+    // TODO: Warning: The buildPreset 'npm-library' is not supported.
+
+
+    return normalizeBuildConfig(context, unPresetConfigs['npm-library'], deps);
+  } // If the user does not configure buildConfig and buildPreset,
+  // the configuration is generated based on packageMode and packageField
+
+
+  const legacyBuildConfig = getNormalizeModuleConfigByPackageModeAndFileds(api, buildFeatOption);
+  return normalizeBuildConfig(context, legacyBuildConfig, deps);
+};
+/* eslint-enable max-lines */