@modern-js/module-tools 1.5.8 → 1.6.1

package/dist/js/node/{tasks → features/build/bundleless}/generator-dts/index.js

@@ -1,16 +1,23 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genDts = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
 var _utils = require("@modern-js/utils");
 
-var _utils2 = require("./utils");
+var _error = require("../../error");
 
-const core = _utils.Import.lazy('@modern-js/core', require);
+var _utils2 = require("../../utils");
 
-const argv = _utils.Import.lazy('process.argv', require);
+var _utils3 = require("./utils");
 
-const utils = _utils.Import.lazy('./utils', require);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-let removeTsconfigPath = '';
+const utils = _utils.Import.lazy('./utils', require);
 
 const getProjectTsconfig = tsconfigPath => {
   if (!tsconfigPath || !_utils.fs.existsSync(tsconfigPath)) {
@@ -21,7 +28,6 @@ const getProjectTsconfig = tsconfigPath => {
 };
 
 const resolveLog = (childProgress, {
-  tsCheck: _tsCheck = false,
   watch: _watch = false
 } = {}) => {
   var _childProgress$stdout, _childProgress$stdout2, _childProgress$stderr;
@@ -32,11 +38,8 @@ const resolveLog = (childProgress, {
    * watch 模式下，则使用这里的信息
    */
   (_childProgress$stdout = childProgress.stdout) === null || _childProgress$stdout === void 0 ? void 0 : _childProgress$stdout.on('data', data => {
-    if (!_tsCheck) {
-      return;
-    }
-
     if (_watch) {
+      console.info((0, _utils2.watchSectionTitle)('[Bundleless:DTS]', _utils2.SectionTitleStatus.Log));
       console.info(data.toString());
     }
   }); // 正常以下内容都不会触发，因为tsc 不会产生以下类型的log信息，不过防止意外情况
@@ -53,97 +56,79 @@ const generatorDts = async (_, config) => {
   const {
     tsconfigPath,
     distDir,
-    sourceDirName = 'src',
-    projectData: {
-      appDirectory
-    },
-    tsCheck = false,
+    sourceDir = 'src',
+    appDirectory,
     watch = false
   } = config;
   const userTsconfig = getProjectTsconfig(tsconfigPath);
   const willDeleteTsconfigPath = utils.generatorTsConfig(userTsconfig, {
     appDirectory,
     distDir,
-    sourceDir: sourceDirName
+    sourceDir
   });
-  removeTsconfigPath = willDeleteTsconfigPath;
-  const tscBinFile = (0, _utils2.getTscBinPath)(appDirectory);
+  const tscBinFile = (0, _utils3.getTscBinPath)(appDirectory);
   const watchParams = watch ? ['-w'] : [];
-  const childProgress = (0, _utils.execa)(tscBinFile, ['-p', willDeleteTsconfigPath, ...watchParams], {
+  const childProgress = (0, _utils.execa)(tscBinFile, ['-p', willDeleteTsconfigPath,
+  /* Required parameter, use it stdout have color */
+  '--pretty', // https://github.com/microsoft/TypeScript/issues/21824
+  '--preserveWatchOutput', ...watchParams], {
     stdio: 'pipe',
     cwd: appDirectory
   });
   resolveLog(childProgress, {
-    tsCheck,
     watch
   });
 
   try {
     await childProgress;
-    console.info('[TSC Compiler]: Successfully');
   } catch (e) {
-    if (!tsCheck) {
-      console.info(`There are some type warnings, which can be checked by configuring 'output.disableTsChecker = false'`);
-    } // 通过使用 execa，可以将 tsc 的 data 类型的报错信息变为异常错误信息
-    else if ((0, _utils.isObject)(e) && e.stdout) {
-      console.error(e.stdout);
-    } else {
-      console.error(e);
+    if (e instanceof Error) {
+      throw new _error.InternalDTSError(e, {
+        buildType: 'bundleless'
+      });
     }
   }
 
   _utils.fs.removeSync(willDeleteTsconfigPath);
 };
 
-const taskMain = async ({
-  modernConfig
-}) => {
-  const processArgv = argv(process.argv.slice(2));
-  const config = processArgv({
-    appDirectory: process.cwd(),
-    srcDir: 'src',
-    distDir: 'dist/types',
-    tsconfigPath: './tsconfig.json',
-    sourceDirName: 'src'
-  });
-  const option = {
-    srcDir: config.srcDir,
-    distDir: config.distDir,
-    projectData: {
-      appDirectory: config.appDirectory
+const genDts = async (api, config) => {
+  const {
+    outputPath,
+    tsconfig: tsconfigPath,
+    watch,
+    bundlelessOptions: {
+      sourceDir
     },
-    tsconfigPath: config.tsconfigPath,
-    watch: config.watch,
-    tsCheck: config.tsCheck,
-    sourceDirName: config.sourceDirName
-  };
-  await generatorDts(modernConfig, option); // // TODO: watch 模式下无法转换
-
-  utils.resolveAlias(modernConfig, option);
-};
-
-(async () => {
-  let options;
+    enableDts
+  } = config;
 
-  if (process.env.CORE_INIT_OPTION_FILE) {
-    ({
-      options
-    } = require(process.env.CORE_INIT_OPTION_FILE));
+  if (!enableDts) {
+    return;
   }
 
   const {
-    resolved
-  } = await core.cli.init([], options);
+    appDirectory
+  } = api.useAppContext();
+  const modernConfig = api.useResolvedConfigContext();
+  const {
+    output: {
+      path: distPath = 'dist'
+    }
+  } = modernConfig;
 
-  (async () => {
-    try {
-      await taskMain({
-        modernConfig: resolved
-      });
-    } catch (e) {
-      console.error(e.message);
+  const distDir = _path.default.join(appDirectory, distPath, outputPath);
 
-      _utils.fs.removeSync(removeTsconfigPath);
-    }
-  })();
-})();
+  const option = {
+    appDirectory,
+    distDir,
+    tsconfigPath,
+    watch,
+    sourceDir
+  };
+  await generatorDts(modernConfig, option); // TODO: watch 模式下无法转换
+
+  utils.resolveAlias(modernConfig, option);
+};
+
+exports.genDts = genDts;

package/dist/js/node/{tasks → features/build/bundleless}/generator-dts/utils.js

@@ -21,18 +21,16 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 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 babel = _utils.Import.lazy('../../utils/babel', require);
+const babel = _utils.Import.lazy('../../../../utils/babel', require);
 
-const tsPathsTransform = _utils.Import.lazy('../../utils/tspaths-transform', require);
-
-const constants = _utils.Import.lazy('../constants', require);
+const tsPathsTransform = _utils.Import.lazy('../../../../utils/tspaths-transform', require);
 
 const generatorTsConfig = (projectTsconfig, {
   appDirectory,
   distDir,
   sourceDir: _sourceDir = 'src'
 }) => {
-  var _projectTsconfig$comp, _projectTsconfig$comp2, _projectTsconfig$incl, _projectTsconfig$excl;
+  var _projectTsconfig$comp, _projectTsconfig$comp2, _ref, _projectTsconfig$excl;
 
   const tempPath = path.resolve(appDirectory, './node_modules');
   const resolvePath = path.relative(tempPath, appDirectory); // const rootDir = projectTsconfig.compilerOptions?.rootDir
@@ -42,8 +40,9 @@ const generatorTsConfig = (projectTsconfig, {
 
   const rootDir = path.join(resolvePath, _sourceDir);
   const baseUrl = (_projectTsconfig$comp = projectTsconfig.compilerOptions) !== null && _projectTsconfig$comp !== void 0 && _projectTsconfig$comp.baseUrl ? path.join(appDirectory, (_projectTsconfig$comp2 = projectTsconfig.compilerOptions) === null || _projectTsconfig$comp2 === void 0 ? void 0 : _projectTsconfig$comp2.baseUrl) : appDirectory; // if include = ['src'], final include should be ['../src']
+  // const include = projectTsconfig.include?.map(includePath =>
 
-  const include = (_projectTsconfig$incl = projectTsconfig.include) === null || _projectTsconfig$incl === void 0 ? void 0 : _projectTsconfig$incl.map(includePath => path.join(resolvePath, includePath));
+  const include = (_ref = [_sourceDir]) === null || _ref === void 0 ? void 0 : _ref.map(includePath => path.join(resolvePath, includePath));
   const exclude = (_projectTsconfig$excl = projectTsconfig.exclude) === null || _projectTsconfig$excl === void 0 ? void 0 : _projectTsconfig$excl.map(excludePath => path.join(resolvePath, excludePath));
   const resetConfig = {
     compilerOptions: {
@@ -63,7 +62,7 @@ const generatorTsConfig = (projectTsconfig, {
       isolatedModules: true
     }
   };
-  const tempTsconfigPath = path.join(tempPath, constants.tempTsconfigName);
+  const tempTsconfigPath = path.join(tempPath, `tsconfig.${Date.now()}.${(0, _utils.nanoid)()}.json`);
 
   _utils.fs.ensureFileSync(tempTsconfigPath);
 
@@ -87,14 +86,14 @@ const resolveAlias = (modernConfig, config, watchFilenames = []) => {
     absolute: true
   });
   const alias = babel.getFinalAlias(modernConfig, {
-    appDirectory: config.projectData.appDirectory,
-    tsconfigPath: config.tsconfigPath || path.join(config.projectData.appDirectory, './tsconfig.json'),
+    appDirectory: config.appDirectory,
+    tsconfigPath: config.tsconfigPath || path.join(config.appDirectory, './tsconfig.json'),
     sourceAbsDir: config.distDir
   });
   const mergedPaths = alias.isTsPath ? alias.paths || {} : _objectSpread(_objectSpread({}, defaultPaths), alias.paths || {});
   const result = tsPathsTransform.transformDtsAlias({
     filenames: dtsFilenames,
-    baseUrl: path.join(config.projectData.appDirectory, output.path || 'dist'),
+    baseUrl: path.join(config.appDirectory, output.path || 'dist'),
     paths: mergedPaths
   });
 

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.build = void 0;
+
+var _utils = require("@modern-js/utils");
+
+var _pMap = _interopRequireDefault(require("p-map"));
+
+var _runBabel = require("./runBabel");
+
+var _style = require("./style");
+
+var _generatorDts = require("./generator-dts");
+
+var _copyAssets = require("./copy-assets");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const build = async (api, config, legacyOptions) => {
+  // valid format is umd
+  if (config.format === 'umd') {
+    console.info(_utils.chalk.yellowBright('bundleless 构建暂时不支持 umd 格式'));
+    return;
+  }
+
+  if (legacyOptions !== null && legacyOptions !== void 0 && legacyOptions.styleOnly) {
+    await (0, _style.buildStyle)(api, config);
+    return;
+  }
+
+  const tasks = config.dtsOnly ? [_generatorDts.genDts] : [_runBabel.runBabelBuild, _generatorDts.genDts, _style.buildStyle, _copyAssets.copyStaticAssets];
+  await (0, _pMap.default)(tasks, async task => {
+    await task(api, config);
+  });
+};
+
+exports.build = build;

package/dist/js/node/features/build/bundleless/runBabel.js

@@ -0,0 +1,309 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBabelBuild = exports.jsFileSuffix = exports.haveNotAnyJsFile = exports.getWillCompilerCode = exports.buildSourceCode = exports.BabelBuildError = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _error = require("../error");
+
+var _utils2 = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class BabelBuildError extends Error {
+  constructor(message, opts) {
+    super(message);
+
+    _defineProperty(this, "summary", void 0);
+
+    _defineProperty(this, "details", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.summary = opts === null || opts === void 0 ? void 0 : opts.summary;
+    this.details = opts === null || opts === void 0 ? void 0 : opts.details;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      summary,
+      details = []
+    } = this;
+    msgs.push(_utils.chalk.red.bold(summary));
+
+    for (const detail of details) {
+      msgs.push(detail.content);
+      msgs.push('\n');
+    }
+
+    return msgs;
+  }
+
+}
+
+exports.BabelBuildError = BabelBuildError;
+
+const babelCompiler = _utils.Import.lazy('@modern-js/babel-compiler', require);
+
+const bc = _utils.Import.lazy('../../../utils/babel', require);
+
+const ts = _utils.Import.lazy('../../../utils/tsconfig', require); // const logger: typeof import('../logger') = Import.lazy('../logger', require);
+
+
+const getExts = (isTs, tsconfig) => {
+  // TODO: 是否受控tsconfig.json 里的jsx配置
+  let exts = [];
+
+  if (isTs) {
+    var _tsconfig$compilerOpt;
+
+    exts = tsconfig !== null && tsconfig !== void 0 && (_tsconfig$compilerOpt = tsconfig.compilerOptions) !== null && _tsconfig$compilerOpt !== void 0 && _tsconfig$compilerOpt.allowJs ? ['.ts', '.tsx', '.js', '.jsx'] : ['.ts', '.tsx'];
+  } else {
+    exts = ['.js', '.jsx'];
+  }
+
+  return exts;
+};
+
+const getWillCompilerCode = (srcDirOrFile, option) => {
+  const {
+    tsconfig,
+    isTsProject
+  } = option; // 如果是一个文件路径，则直接返回
+
+  if (_utils.fs.existsSync(srcDirOrFile) && _utils.fs.lstatSync(srcDirOrFile).isFile()) {
+    return [srcDirOrFile];
+  }
+
+  const exts = getExts(isTsProject, tsconfig);
+  const globPattern = `${srcDirOrFile}/**/*{${exts.join(',')}}`;
+
+  const files = _utils.glob.sync(globPattern, {
+    ignore: [`${srcDirOrFile}/**/*.d.ts`],
+    absolute: true
+  });
+
+  return files;
+};
+
+exports.getWillCompilerCode = getWillCompilerCode;
+
+const buildSourceCode = async config => {
+  const {
+    willCompilerDirOrFile,
+    tsconfigPath,
+    babelConfig,
+    srcRootDir,
+    distDir,
+    watch
+  } = config;
+  const tsconfig = ts.readTsConfig(tsconfigPath);
+  const willCompilerFiles = getWillCompilerCode(willCompilerDirOrFile, {
+    tsconfig,
+    isTsProject: Boolean(tsconfig)
+  });
+
+  if (watch) {
+    const emitter = await babelCompiler.compiler({
+      quiet: true,
+      enableVirtualDist: true,
+      enableWatch: true,
+      rootDir: srcRootDir,
+      filenames: willCompilerFiles,
+      distDir,
+      watchDir: srcRootDir,
+      extensions: getExts(Boolean(tsconfig), tsconfig),
+      ignore: ['*.d.ts']
+    }, babelConfig);
+    return emitter;
+  } else {
+    return babelCompiler.compiler({
+      quiet: true,
+      enableVirtualDist: true,
+      rootDir: srcRootDir,
+      filenames: willCompilerFiles,
+      distDir,
+      // enableWatch: watch,
+      ignore: ['*.d.ts']
+    }, babelConfig);
+  }
+};
+
+exports.buildSourceCode = buildSourceCode;
+
+const generatorRealFiles = virtualDists => {
+  for (const virtualDist of virtualDists) {
+    const {
+      distPath,
+      code,
+      sourcemap,
+      sourceMapPath
+    } = virtualDist;
+
+    _utils.fs.ensureFileSync(distPath);
+
+    _utils.fs.writeFileSync(distPath, code);
+
+    if (sourcemap.length > 0) {
+      _utils.fs.ensureFileSync(sourceMapPath);
+
+      _utils.fs.writeFileSync(sourceMapPath, sourcemap);
+    }
+  }
+};
+/**
+ * when modern build, only throw Error or silent
+ * @param outputResults
+ * @param context
+ */
+
+
+const outputDist = (outputResults, context) => {
+  const {
+    code,
+    message,
+    messageDetails,
+    virtualDists = []
+  } = outputResults;
+
+  if (code === 0) {
+    generatorRealFiles(virtualDists);
+  } else if (messageDetails && messageDetails.length > 0) {
+    const babelError = new BabelBuildError('bundleless failed', {
+      summary: message,
+      details: messageDetails
+    });
+    throw new _error.InternalBuildError(babelError, _objectSpread(_objectSpread({}, context), {}, {
+      buildType: 'bundleless'
+    }));
+  }
+};
+
+const jsFileSuffix = ['js', 'jsx', 'ts', 'tsx'];
+exports.jsFileSuffix = jsFileSuffix;
+
+const haveNotAnyJsFile = async sourceDir => {
+  const files = await (0, _utils.globby)((0, _utils.slash)(`${sourceDir}/**/*.{${jsFileSuffix.join(',')}}`));
+  return files.length === 0;
+};
+
+exports.haveNotAnyJsFile = haveNotAnyJsFile;
+
+const runBabelBuild = async (api, config) => {
+  const {
+    bundlelessOptions,
+    tsconfig,
+    target,
+    format,
+    outputPath,
+    watch,
+    sourceMap
+  } = config;
+  const {
+    appDirectory
+  } = api.useAppContext();
+  const modernConfig = api.useResolvedConfigContext();
+  const {
+    output: {
+      path: distPath = 'dist'
+    }
+  } = modernConfig;
+  const {
+    sourceDir = './src'
+  } = bundlelessOptions;
+
+  const sourceAbsDir = _path.default.join(appDirectory, sourceDir);
+
+  const tsconfigPath = _path.default.join(appDirectory, tsconfig);
+
+  if (await haveNotAnyJsFile(sourceAbsDir)) {
+    return;
+  } // TODO: Refactoring based on format and target
+
+
+  const syntax = target === 'es5' ? 'es5' : 'es6+';
+  const type = format === 'cjs' ? 'commonjs' : 'module';
+  const titleText = `[Bundleless:Babel: ${format}_${target}]`;
+  const buildConfig = {
+    format,
+    target,
+    babelConfig: bc.resolveBabelConfig(appDirectory, modernConfig, sourceMap, bundlelessOptions, {
+      sourceAbsDir,
+      tsconfigPath,
+      syntax,
+      type
+    })
+  };
+
+  const distDir = _path.default.join(appDirectory, distPath, outputPath);
+
+  const result = await buildSourceCode({
+    appDirectory,
+    distDir,
+    srcRootDir: sourceAbsDir,
+    willCompilerDirOrFile: sourceAbsDir,
+    tsconfigPath,
+    babelConfig: buildConfig.babelConfig,
+    watch
+  });
+
+  if (watch) {
+    const emitter = result;
+    emitter.on(babelCompiler.BuildWatchEvent.firstCompiler, result => {
+      if (result.code === 1) {
+        console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Fail));
+        console.error(result.message);
+
+        for (const detail of result.messageDetails || []) {
+          console.error(detail.content);
+        }
+      } else {
+        generatorRealFiles(result.virtualDists);
+        console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Success));
+      }
+    });
+    emitter.on(babelCompiler.BuildWatchEvent.watchingCompiler, result => {
+      if (result.code === 1) {
+        var _result$virtualDists;
+
+        // console.error(logger.clearFlag);
+        console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Fail));
+        console.error(result.message);
+
+        for (const detail of result.messageDetails || []) {
+          console.error(detail.content);
+        }
+
+        if (Array.isArray(result.virtualDists) && ((_result$virtualDists = result.virtualDists) === null || _result$virtualDists === void 0 ? void 0 : _result$virtualDists.length) > 0) {
+          generatorRealFiles(result.virtualDists);
+        }
+      } else {
+        generatorRealFiles(result.virtualDists);
+        console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Success));
+      }
+    });
+    await emitter.watch();
+  } else {
+    outputDist(result, {
+      target,
+      format
+    });
+  }
+};
+
+exports.runBabelBuild = runBabelBuild;