@modern-js/server-utils 1.15.1-beta.0 → 1.15.1-beta.1

package/dist/js/modern/common/index.js

@@ -1,26 +1,32 @@
 import * as path from 'path';
 import { fs } from '@modern-js/utils';
-import recursive from 'recursive-readdir';
 import { compileByTs } from "../compilers/typescript";
 import { compileByBabel } from "../compilers/babel";
 export const FILE_EXTENSIONS = ['.js', '.ts', '.mjs', '.ejs'];
-export const TS_CONFIG_FILENAME = 'tsconfig.json';
+
+const validateAbsolutePath = (filename, message) => {
+  if (!path.isAbsolute(filename)) {
+    throw new Error(message);
+  }
+};
+
+const validateAbsolutePaths = (filenames, messageFunc) => {
+  filenames.forEach(filename => validateAbsolutePath(filename, messageFunc(filename)));
+};
+
 export const compile = async (appDirectory, modernConfig, compileOptions) => {
-  const tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
-  const isTsProject = await fs.pathExists(tsConifgPath);
+  const {
+    sourceDirs,
+    distDir,
+    tsconfigPath
+  } = compileOptions;
+  validateAbsolutePaths(sourceDirs, dir => `source dir ${dir} is not an absolute path.`);
+  validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+  const isTsProject = tsconfigPath && (await fs.pathExists(tsconfigPath));
 
   if (isTsProject) {
     await compileByTs(appDirectory, modernConfig, compileOptions);
   } else {
     await compileByBabel(appDirectory, modernConfig, compileOptions);
   }
-};
-export const recursiveReadTsFiles = async dirname => {
-  const ignoreFunc = filename => {
-    const extname = path.extname(filename);
-    return !['.ts', '.d.ts'].includes(extname);
-  };
-
-  const files = await recursive(dirname, [ignoreFunc]);
-  return files;
 };

package/dist/js/modern/compilers/babel/index.js

@@ -86,32 +86,29 @@ export const resolveBabelConfig = (appDirectory, modernConfig, option // FIXME:
 };
 export const compileByBabel = async (appDirectory, modernConfig, compileOptions) => {
   const {
-    patterns
+    sourceDirs,
+    distDir,
+    tsconfigPath
   } = compileOptions;
-  const results = await Promise.all(patterns.map(async pattern => {
-    const {
-      from,
-      to,
-      tsconfigPath
-    } = pattern;
+  const results = await Promise.all(sourceDirs.map(async sourceDir => {
     const babelConfig = resolveBabelConfig(appDirectory, modernConfig, {
       tsconfigPath: tsconfigPath ? tsconfigPath : '',
       syntax: 'es6+',
       type: 'commonjs'
     });
 
-    if (await fs.pathExists(from)) {
-      const basename = path.basename(from);
-      const targetDir = path.join(to, basename);
-      await fs.copy(from, targetDir, {
+    if (await fs.pathExists(sourceDir)) {
+      const basename = path.basename(sourceDir);
+      const targetDir = path.join(distDir, basename);
+      await fs.copy(sourceDir, targetDir, {
         filter: src => !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath
       });
     }
 
     return compiler({
       rootDir: appDirectory,
-      distDir: to,
-      sourceDir: from,
+      distDir: distDir,
+      sourceDir: sourceDir,
       extensions: FILE_EXTENSIONS
     }, babelConfig);
   }));

package/dist/js/modern/compilers/typescript/index.js

@@ -4,11 +4,8 @@ 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; }
 
-// from to tsconfigpath
-// root dir
 import path from 'path';
 import { logger, getAlias, fs } from '@modern-js/utils';
-import { TS_CONFIG_FILENAME } from "../../common";
 import { TypescriptLoader } from "./typescript-loader";
 import { tsconfigPathsBeforeHookFactory } from "./tsconfig-paths-plugin";
 import ts from 'typescript';
@@ -35,68 +32,63 @@ const copyFiles = async (from, to, tsconfigPath) => {
       filter: src => !['.ts'].includes(path.extname(src)) && src !== tsconfigPath
     });
   }
-}; // TODO: 分离特殊的业务逻辑，通用化
-
+};
 
 export const compileByTs = async (appDirectory, modernConfig, compileOptions) => {
   logger.info(`Running ts compile...`);
-  const rootTsconfigPath = path.join(appDirectory, TS_CONFIG_FILENAME);
   const {
-    patterns
+    sourceDirs,
+    distDir,
+    tsconfigPath
   } = compileOptions;
+  if (!tsconfigPath) return;
   const ts = new TypescriptLoader({
     appDirectory
   }).load();
   const createProgram = ts.createIncrementalProgram || ts.createProgram;
   const formatHost = getFormatHost(ts);
-
-  for (const pattern of patterns) {
-    const {
-      tsconfigPath = rootTsconfigPath,
-      from,
-      to
-    } = pattern;
-    const basename = path.basename(from);
-    const targetDir = path.join(to, basename);
-    logger.info(`Compile ${from}`);
-    const {
-      alias
-    } = modernConfig.source;
-    const aliasOption = getAlias(alias || {}, {
-      appDirectory,
-      tsconfigPath
-    });
-    const {
-      paths = {},
-      absoluteBaseUrl = './'
-    } = aliasOption;
-    const {
-      options,
-      fileNames,
-      projectReferences
-    } = readTsConfigByFile(tsconfigPath);
-    const rootNames = fileNames.filter(fileName => {
-      return fileName.endsWith('.d.ts') || fileName.includes(from);
-    });
-    let program = createProgram.call(ts, {
-      rootNames: rootNames,
-      projectReferences,
-      options: _objectSpread(_objectSpread({}, options), {}, {
-        outDir: targetDir
-      })
-    });
-    const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
-    const emitResult = program.emit(undefined, undefined, undefined, undefined, {
-      before: [tsconfigPathsPlugin]
+  const {
+    alias
+  } = modernConfig.source;
+  const aliasOption = getAlias(alias || {}, {
+    appDirectory,
+    tsconfigPath
+  });
+  const {
+    paths = {},
+    absoluteBaseUrl = './'
+  } = aliasOption;
+  const {
+    options,
+    fileNames,
+    projectReferences
+  } = readTsConfigByFile(tsconfigPath);
+  const rootNames = fileNames.filter(fileName => {
+    return fileName.endsWith('.d.ts') || sourceDirs.some(sourceDir => {
+      return fileName.includes(sourceDir);
     });
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  });
+  const targetDir = path.join(appDirectory, './dist');
+  let program = createProgram.call(ts, {
+    rootNames: rootNames,
+    projectReferences,
+    options: _objectSpread(_objectSpread({}, options), {}, {
+      outDir: targetDir
+    })
+  });
+  const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+  const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+    before: [tsconfigPathsPlugin]
+  });
+  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
 
-    if (allDiagnostics.length > 0) {
-      logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
-      process.exit(1);
-    }
+  if (allDiagnostics.length > 0) {
+    logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
+    process.exit(1);
+  }
 
-    await copyFiles(from, to, tsconfigPath);
+  for (const source of sourceDirs) {
+    await copyFiles(source, distDir, tsconfigPath);
   }
 };
 

package/dist/js/node/common/index.js

@@ -3,32 +3,42 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.recursiveReadTsFiles = exports.compile = exports.TS_CONFIG_FILENAME = exports.FILE_EXTENSIONS = void 0;
+exports.compile = exports.FILE_EXTENSIONS = void 0;
 
 var path = _interopRequireWildcard(require("path"));
 
 var _utils = require("@modern-js/utils");
 
-var _recursiveReaddir = _interopRequireDefault(require("recursive-readdir"));
-
 var _typescript = require("../compilers/typescript");
 
 var _babel = require("../compilers/babel");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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; }
 
 const FILE_EXTENSIONS = ['.js', '.ts', '.mjs', '.ejs'];
 exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
-const TS_CONFIG_FILENAME = 'tsconfig.json';
-exports.TS_CONFIG_FILENAME = TS_CONFIG_FILENAME;
+
+const validateAbsolutePath = (filename, message) => {
+  if (!path.isAbsolute(filename)) {
+    throw new Error(message);
+  }
+};
+
+const validateAbsolutePaths = (filenames, messageFunc) => {
+  filenames.forEach(filename => validateAbsolutePath(filename, messageFunc(filename)));
+};
 
 const compile = async (appDirectory, modernConfig, compileOptions) => {
-  const tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
-  const isTsProject = await _utils.fs.pathExists(tsConifgPath);
+  const {
+    sourceDirs,
+    distDir,
+    tsconfigPath
+  } = compileOptions;
+  validateAbsolutePaths(sourceDirs, dir => `source dir ${dir} is not an absolute path.`);
+  validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+  const isTsProject = tsconfigPath && (await _utils.fs.pathExists(tsconfigPath));
 
   if (isTsProject) {
     await (0, _typescript.compileByTs)(appDirectory, modernConfig, compileOptions);
@@ -37,16 +47,4 @@ const compile = async (appDirectory, modernConfig, compileOptions) => {
   }
 };
 
-exports.compile = compile;
-
-const recursiveReadTsFiles = async dirname => {
-  const ignoreFunc = filename => {
-    const extname = path.extname(filename);
-    return !['.ts', '.d.ts'].includes(extname);
-  };
-
-  const files = await (0, _recursiveReaddir.default)(dirname, [ignoreFunc]);
-  return files;
-};
-
-exports.recursiveReadTsFiles = recursiveReadTsFiles;
+exports.compile = compile;

package/dist/js/node/compilers/babel/index.js

@@ -135,32 +135,29 @@ exports.resolveBabelConfig = resolveBabelConfig;
 
 const compileByBabel = async (appDirectory, modernConfig, compileOptions) => {
   const {
-    patterns
+    sourceDirs,
+    distDir,
+    tsconfigPath
   } = compileOptions;
-  const results = await Promise.all(patterns.map(async pattern => {
-    const {
-      from,
-      to,
-      tsconfigPath
-    } = pattern;
+  const results = await Promise.all(sourceDirs.map(async sourceDir => {
     const babelConfig = resolveBabelConfig(appDirectory, modernConfig, {
       tsconfigPath: tsconfigPath ? tsconfigPath : '',
       syntax: 'es6+',
       type: 'commonjs'
     });
 
-    if (await _utils.fs.pathExists(from)) {
-      const basename = path.basename(from);
-      const targetDir = path.join(to, basename);
-      await _utils.fs.copy(from, targetDir, {
+    if (await _utils.fs.pathExists(sourceDir)) {
+      const basename = path.basename(sourceDir);
+      const targetDir = path.join(distDir, basename);
+      await _utils.fs.copy(sourceDir, targetDir, {
         filter: src => !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath
       });
     }
 
     return (0, _babelCompiler.compiler)({
       rootDir: appDirectory,
-      distDir: to,
-      sourceDir: from,
+      distDir: distDir,
+      sourceDir: sourceDir,
       extensions: _common.FILE_EXTENSIONS
     }, babelConfig);
   }));

package/dist/js/node/compilers/typescript/index.js

@@ -9,8 +9,6 @@ var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
-var _common = require("../../common");
-
 var _typescriptLoader = require("./typescript-loader");
 
 var _tsconfigPathsPlugin = require("./tsconfig-paths-plugin");
@@ -50,75 +48,67 @@ const copyFiles = async (from, to, tsconfigPath) => {
       filter: src => !['.ts'].includes(_path.default.extname(src)) && src !== tsconfigPath
     });
   }
-}; // TODO: 分离特殊的业务逻辑，通用化
-
+};
 
 const compileByTs = async (appDirectory, modernConfig, compileOptions) => {
   _utils.logger.info(`Running ts compile...`);
 
-  const rootTsconfigPath = _path.default.join(appDirectory, _common.TS_CONFIG_FILENAME);
-
   const {
-    patterns
+    sourceDirs,
+    distDir,
+    tsconfigPath
   } = compileOptions;
+  if (!tsconfigPath) return;
   const ts = new _typescriptLoader.TypescriptLoader({
     appDirectory
   }).load();
   const createProgram = ts.createIncrementalProgram || ts.createProgram;
   const formatHost = getFormatHost(ts);
-
-  for (const pattern of patterns) {
-    const {
-      tsconfigPath = rootTsconfigPath,
-      from,
-      to
-    } = pattern;
-
-    const basename = _path.default.basename(from);
-
-    const targetDir = _path.default.join(to, basename);
-
-    _utils.logger.info(`Compile ${from}`);
-
-    const {
-      alias
-    } = modernConfig.source;
-    const aliasOption = (0, _utils.getAlias)(alias || {}, {
-      appDirectory,
-      tsconfigPath
-    });
-    const {
-      paths = {},
-      absoluteBaseUrl = './'
-    } = aliasOption;
-    const {
-      options,
-      fileNames,
-      projectReferences
-    } = readTsConfigByFile(tsconfigPath);
-    const rootNames = fileNames.filter(fileName => {
-      return fileName.endsWith('.d.ts') || fileName.includes(from);
-    });
-    let program = createProgram.call(ts, {
-      rootNames: rootNames,
-      projectReferences,
-      options: _objectSpread(_objectSpread({}, options), {}, {
-        outDir: targetDir
-      })
-    });
-    const tsconfigPathsPlugin = (0, _tsconfigPathsPlugin.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
-    const emitResult = program.emit(undefined, undefined, undefined, undefined, {
-      before: [tsconfigPathsPlugin]
+  const {
+    alias
+  } = modernConfig.source;
+  const aliasOption = (0, _utils.getAlias)(alias || {}, {
+    appDirectory,
+    tsconfigPath
+  });
+  const {
+    paths = {},
+    absoluteBaseUrl = './'
+  } = aliasOption;
+  const {
+    options,
+    fileNames,
+    projectReferences
+  } = readTsConfigByFile(tsconfigPath);
+  const rootNames = fileNames.filter(fileName => {
+    return fileName.endsWith('.d.ts') || sourceDirs.some(sourceDir => {
+      return fileName.includes(sourceDir);
     });
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-
-    if (allDiagnostics.length > 0) {
-      _utils.logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
-
-      process.exit(1);
-    }
+  });
+
+  const targetDir = _path.default.join(appDirectory, './dist');
+
+  let program = createProgram.call(ts, {
+    rootNames: rootNames,
+    projectReferences,
+    options: _objectSpread(_objectSpread({}, options), {}, {
+      outDir: targetDir
+    })
+  });
+  const tsconfigPathsPlugin = (0, _tsconfigPathsPlugin.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
+  const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+    before: [tsconfigPathsPlugin]
+  });
+  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+  if (allDiagnostics.length > 0) {
+    _utils.logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
+
+    process.exit(1);
+  }
 
-    await copyFiles(from, to, tsconfigPath);
+  for (const source of sourceDirs) {
+    await copyFiles(source, distDir, tsconfigPath);
   }
 };
 

package/dist/js/treeshaking/common/index.js

@@ -2,42 +2,67 @@ import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import * as path from 'path';
 import { fs } from '@modern-js/utils';
-import recursive from 'recursive-readdir';
 import { compileByTs } from "../compilers/typescript";
 import { compileByBabel } from "../compilers/babel";
 export var FILE_EXTENSIONS = ['.js', '.ts', '.mjs', '.ejs'];
-export var TS_CONFIG_FILENAME = 'tsconfig.json';
+
+var validateAbsolutePath = function validateAbsolutePath(filename, message) {
+  if (!path.isAbsolute(filename)) {
+    throw new Error(message);
+  }
+};
+
+var validateAbsolutePaths = function validateAbsolutePaths(filenames, messageFunc) {
+  filenames.forEach(function (filename) {
+    return validateAbsolutePath(filename, messageFunc(filename));
+  });
+};
+
 export var compile = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(appDirectory, modernConfig, compileOptions) {
-    var tsConifgPath, isTsProject;
+    var sourceDirs, distDir, tsconfigPath, isTsProject;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
-            _context.next = 3;
-            return fs.pathExists(tsConifgPath);
+            sourceDirs = compileOptions.sourceDirs, distDir = compileOptions.distDir, tsconfigPath = compileOptions.tsconfigPath;
+            validateAbsolutePaths(sourceDirs, function (dir) {
+              return "source dir ".concat(dir, " is not an absolute path.");
+            });
+            validateAbsolutePath(distDir, "dist dir ".concat(distDir, " is not an absolute path."));
+            _context.t0 = tsconfigPath;
+
+            if (!_context.t0) {
+              _context.next = 8;
+              break;
+            }
 
-          case 3:
-            isTsProject = _context.sent;
+            _context.next = 7;
+            return fs.pathExists(tsconfigPath);
+
+          case 7:
+            _context.t0 = _context.sent;
+
+          case 8:
+            isTsProject = _context.t0;
 
             if (!isTsProject) {
-              _context.next = 9;
+              _context.next = 14;
               break;
             }
 
-            _context.next = 7;
+            _context.next = 12;
             return compileByTs(appDirectory, modernConfig, compileOptions);
 
-          case 7:
-            _context.next = 11;
+          case 12:
+            _context.next = 16;
             break;
 
-          case 9:
-            _context.next = 11;
+          case 14:
+            _context.next = 16;
             return compileByBabel(appDirectory, modernConfig, compileOptions);
 
-          case 11:
+          case 16:
           case "end":
             return _context.stop();
         }
@@ -48,35 +73,4 @@ export var compile = /*#__PURE__*/function () {
   return function compile(_x, _x2, _x3) {
     return _ref.apply(this, arguments);
   };
-}();
-export var recursiveReadTsFiles = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(dirname) {
-    var ignoreFunc, files;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            ignoreFunc = function ignoreFunc(filename) {
-              var extname = path.extname(filename);
-              return !['.ts', '.d.ts'].includes(extname);
-            };
-
-            _context2.next = 3;
-            return recursive(dirname, [ignoreFunc]);
-
-          case 3:
-            files = _context2.sent;
-            return _context2.abrupt("return", files);
-
-          case 5:
-          case "end":
-            return _context2.stop();
-        }
-      }
-    }, _callee2);
-  }));
-
-  return function recursiveReadTsFiles(_x4) {
-    return _ref2.apply(this, arguments);
-  };
 }();

package/dist/js/treeshaking/compilers/babel/index.js

@@ -79,53 +79,52 @@ export var resolveBabelConfig = function resolveBabelConfig(appDirectory, modern
 };
 export var compileByBabel = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appDirectory, modernConfig, compileOptions) {
-    var patterns, results;
+    var sourceDirs, distDir, tsconfigPath, results;
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            patterns = compileOptions.patterns;
+            sourceDirs = compileOptions.sourceDirs, distDir = compileOptions.distDir, tsconfigPath = compileOptions.tsconfigPath;
             _context2.next = 3;
-            return Promise.all(patterns.map( /*#__PURE__*/function () {
-              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(pattern) {
-                var from, to, tsconfigPath, babelConfig, basename, targetDir;
+            return Promise.all(sourceDirs.map( /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(sourceDir) {
+                var babelConfig, basename, targetDir;
                 return _regeneratorRuntime().wrap(function _callee$(_context) {
                   while (1) {
                     switch (_context.prev = _context.next) {
                       case 0:
-                        from = pattern.from, to = pattern.to, tsconfigPath = pattern.tsconfigPath;
                         babelConfig = resolveBabelConfig(appDirectory, modernConfig, {
                           tsconfigPath: tsconfigPath ? tsconfigPath : '',
                           syntax: 'es6+',
                           type: 'commonjs'
                         });
-                        _context.next = 4;
-                        return fs.pathExists(from);
+                        _context.next = 3;
+                        return fs.pathExists(sourceDir);
 
-                      case 4:
+                      case 3:
                         if (!_context.sent) {
-                          _context.next = 9;
+                          _context.next = 8;
                           break;
                         }
 
-                        basename = path.basename(from);
-                        targetDir = path.join(to, basename);
-                        _context.next = 9;
-                        return fs.copy(from, targetDir, {
+                        basename = path.basename(sourceDir);
+                        targetDir = path.join(distDir, basename);
+                        _context.next = 8;
+                        return fs.copy(sourceDir, targetDir, {
                           filter: function filter(src) {
                             return !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath;
                           }
                         });
 
-                      case 9:
+                      case 8:
                         return _context.abrupt("return", compiler({
                           rootDir: appDirectory,
-                          distDir: to,
-                          sourceDir: from,
+                          distDir: distDir,
+                          sourceDir: sourceDir,
                           extensions: FILE_EXTENSIONS
                         }, babelConfig));
 
-                      case 10:
+                      case 9:
                       case "end":
                         return _context.stop();
                     }

package/dist/js/treeshaking/compilers/typescript/index.js

@@ -1,12 +1,9 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-// from to tsconfigpath
-// root dir
 import path from 'path';
 import { logger, getAlias, fs } from '@modern-js/utils';
-import { TS_CONFIG_FILENAME } from "../../common";
 import { TypescriptLoader } from "./typescript-loader";
 import { tsconfigPathsBeforeHookFactory } from "./tsconfig-paths-plugin";
 import ts from 'typescript';
@@ -60,115 +57,105 @@ var copyFiles = /*#__PURE__*/function () {
   return function copyFiles(_x, _x2, _x3) {
     return _ref2.apply(this, arguments);
   };
-}(); // TODO: 分离特殊的业务逻辑，通用化
-
+}();
 
 export var compileByTs = /*#__PURE__*/function () {
   var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appDirectory, modernConfig, compileOptions) {
-    var rootTsconfigPath, patterns, ts, createProgram, formatHost, _iterator, _step, _loop;
+    var sourceDirs, distDir, tsconfigPath, ts, createProgram, formatHost, alias, aliasOption, _aliasOption$paths, paths, _aliasOption$absolute, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, rootNames, targetDir, program, tsconfigPathsPlugin, emitResult, allDiagnostics, _iterator, _step, source;
 
-    return _regeneratorRuntime().wrap(function _callee2$(_context3) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context2.prev = _context2.next) {
           case 0:
             logger.info("Running ts compile...");
-            rootTsconfigPath = path.join(appDirectory, TS_CONFIG_FILENAME);
-            patterns = compileOptions.patterns;
+            sourceDirs = compileOptions.sourceDirs, distDir = compileOptions.distDir, tsconfigPath = compileOptions.tsconfigPath;
+
+            if (tsconfigPath) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return");
+
+          case 4:
             ts = new TypescriptLoader({
               appDirectory: appDirectory
             }).load();
             createProgram = ts.createIncrementalProgram || ts.createProgram;
             formatHost = getFormatHost(ts);
-            _iterator = _createForOfIteratorHelper(patterns);
-            _context3.prev = 7;
-            _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
-              var pattern, _pattern$tsconfigPath, tsconfigPath, from, to, basename, targetDir, alias, aliasOption, _aliasOption$paths, paths, _aliasOption$absolute, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics;
-
-              return _regeneratorRuntime().wrap(function _loop$(_context2) {
-                while (1) {
-                  switch (_context2.prev = _context2.next) {
-                    case 0:
-                      pattern = _step.value;
-                      _pattern$tsconfigPath = pattern.tsconfigPath, tsconfigPath = _pattern$tsconfigPath === void 0 ? rootTsconfigPath : _pattern$tsconfigPath, from = pattern.from, to = pattern.to;
-                      basename = path.basename(from);
-                      targetDir = path.join(to, basename);
-                      logger.info("Compile ".concat(from));
-                      alias = modernConfig.source.alias;
-                      aliasOption = getAlias(alias || {}, {
-                        appDirectory: appDirectory,
-                        tsconfigPath: tsconfigPath
-                      });
-                      _aliasOption$paths = aliasOption.paths, paths = _aliasOption$paths === void 0 ? {} : _aliasOption$paths, _aliasOption$absolute = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption$absolute === void 0 ? './' : _aliasOption$absolute;
-                      _readTsConfigByFile = readTsConfigByFile(tsconfigPath), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
-                      rootNames = fileNames.filter(function (fileName) {
-                        return fileName.endsWith('.d.ts') || fileName.includes(from);
-                      });
-                      program = createProgram.call(ts, {
-                        rootNames: rootNames,
-                        projectReferences: projectReferences,
-                        options: _objectSpread(_objectSpread({}, options), {}, {
-                          outDir: targetDir
-                        })
-                      });
-                      tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
-                      emitResult = program.emit(undefined, undefined, undefined, undefined, {
-                        before: [tsconfigPathsPlugin]
-                      });
-                      allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-
-                      if (allDiagnostics.length > 0) {
-                        logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
-                        process.exit(1);
-                      }
-
-                      _context2.next = 17;
-                      return copyFiles(from, to, tsconfigPath);
-
-                    case 17:
-                    case "end":
-                      return _context2.stop();
-                  }
-                }
-              }, _loop);
+            alias = modernConfig.source.alias;
+            aliasOption = getAlias(alias || {}, {
+              appDirectory: appDirectory,
+              tsconfigPath: tsconfigPath
+            });
+            _aliasOption$paths = aliasOption.paths, paths = _aliasOption$paths === void 0 ? {} : _aliasOption$paths, _aliasOption$absolute = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption$absolute === void 0 ? './' : _aliasOption$absolute;
+            _readTsConfigByFile = readTsConfigByFile(tsconfigPath), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
+            rootNames = fileNames.filter(function (fileName) {
+              return fileName.endsWith('.d.ts') || sourceDirs.some(function (sourceDir) {
+                return fileName.includes(sourceDir);
+              });
+            });
+            targetDir = path.join(appDirectory, './dist');
+            program = createProgram.call(ts, {
+              rootNames: rootNames,
+              projectReferences: projectReferences,
+              options: _objectSpread(_objectSpread({}, options), {}, {
+                outDir: targetDir
+              })
+            });
+            tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+            emitResult = program.emit(undefined, undefined, undefined, undefined, {
+              before: [tsconfigPathsPlugin]
             });
+            allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+            if (allDiagnostics.length > 0) {
+              logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
+              process.exit(1);
+            }
+
+            _iterator = _createForOfIteratorHelper(sourceDirs);
+            _context2.prev = 19;
 
             _iterator.s();
 
-          case 10:
+          case 21:
             if ((_step = _iterator.n()).done) {
-              _context3.next = 14;
+              _context2.next = 27;
               break;
             }
 
-            return _context3.delegateYield(_loop(), "t0", 12);
+            source = _step.value;
+            _context2.next = 25;
+            return copyFiles(source, distDir, tsconfigPath);
 
-          case 12:
-            _context3.next = 10;
+          case 25:
+            _context2.next = 21;
             break;
 
-          case 14:
-            _context3.next = 19;
+          case 27:
+            _context2.next = 32;
             break;
 
-          case 16:
-            _context3.prev = 16;
-            _context3.t1 = _context3["catch"](7);
+          case 29:
+            _context2.prev = 29;
+            _context2.t0 = _context2["catch"](19);
 
-            _iterator.e(_context3.t1);
+            _iterator.e(_context2.t0);
 
-          case 19:
-            _context3.prev = 19;
+          case 32:
+            _context2.prev = 32;
 
             _iterator.f();
 
-            return _context3.finish(19);
+            return _context2.finish(32);
 
-          case 22:
+          case 35:
           case "end":
-            return _context3.stop();
+            return _context2.stop();
         }
       }
-    }, _callee2, null, [[7, 16, 19, 22]]);
+    }, _callee2, null, [[19, 29, 32, 35]]);
   }));
 
   return function compileByTs(_x4, _x5, _x6) {

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

@@ -5,10 +5,10 @@ export interface Pattern {
   tsconfigPath?: string;
 }
 export interface CompileOptions {
-  patterns: Pattern[];
+  sourceDirs: string[];
+  distDir: string;
+  tsconfigPath?: string;
 }
 export declare type CompileFunc = (appDirectory: string, modernConfig: NormalizedConfig, compileOptions: CompileOptions) => Promise<void>;
 export declare const FILE_EXTENSIONS: string[];
-export declare const TS_CONFIG_FILENAME = "tsconfig.json";
-export declare const compile: CompileFunc;
-export declare const recursiveReadTsFiles: (dirname: string) => Promise<string[]>;
+export declare const compile: CompileFunc;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.15.1-beta.0",
+  "version": "1.15.1-beta.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",