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

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

@@ -0,0 +1,26 @@
+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';
+export const compile = async (appDirectory, modernConfig, compileOptions) => {
+  const tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
+  const isTsProject = await fs.pathExists(tsConifgPath);
+
+  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/{babel.js → compilers/babel/index.js}

@@ -4,8 +4,11 @@ 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; }
 
+import * as path from 'path';
 import { getBabelChain, applyUserBabelConfig } from '@modern-js/babel-preset-lib';
 import { fs, json5, getAlias, applyOptionsChain } from '@modern-js/utils';
+import { compiler } from '@modern-js/babel-compiler';
+import { FILE_EXTENSIONS } from "../../common";
 export * from '@babel/core';
 export const readTsConfig = (tsconfigPath, noExistReturn = null) => {
   // 如果不存在，则返回 noExistReturn
@@ -80,4 +83,41 @@ export const resolveBabelConfig = (appDirectory, modernConfig, option // FIXME:
 
   const userBabelConfig = modernConfig.tools.babel;
   return applyUserBabelConfig(internalBabelConfig, userBabelConfig);
+};
+export const compileByBabel = async (appDirectory, modernConfig, compileOptions) => {
+  const {
+    patterns
+  } = compileOptions;
+  const results = await Promise.all(patterns.map(async pattern => {
+    const {
+      from,
+      to,
+      tsconfigPath
+    } = pattern;
+    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, {
+        filter: src => !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath
+      });
+    }
+
+    return compiler({
+      rootDir: appDirectory,
+      distDir: to,
+      sourceDir: from,
+      extensions: FILE_EXTENSIONS
+    }, babelConfig);
+  }));
+  results.forEach(result => {
+    if (result.code === 1) {
+      throw new Error(result.message);
+    }
+  });
 };

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

@@ -0,0 +1,109 @@
+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; }
+
+// 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';
+
+const readTsConfigByFile = tsConfigFile => {
+  const parsedCmd = ts.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, ts.sys);
+  const {
+    options,
+    fileNames,
+    projectReferences
+  } = parsedCmd;
+  return {
+    options,
+    fileNames,
+    projectReferences
+  };
+};
+
+const copyFiles = async (from, to, tsconfigPath) => {
+  if (await fs.pathExists(from)) {
+    const basename = path.basename(from);
+    const targetDir = path.join(to, basename);
+    await fs.copy(from, targetDir, {
+      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
+  } = compileOptions;
+  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 allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+    if (allDiagnostics.length > 0) {
+      logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
+      process.exit(1);
+    }
+
+    await copyFiles(from, to, tsconfigPath);
+  }
+};
+
+const getFormatHost = ts => {
+  return {
+    getCanonicalFileName: path => path,
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getNewLine: () => ts.sys.newLine
+  };
+};

package/dist/js/modern/compilers/typescript/tsconfig-paths-plugin.js

@@ -0,0 +1,138 @@
+import * as os from 'os';
+import path, { dirname, posix } from 'path';
+import { createMatchPath } from 'tsconfig-paths';
+
+const isRegExpKey = str => {
+  return str.startsWith('^') || str.endsWith('$');
+};
+
+const resolveAliasPath = (baseUrl, filePath) => {
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+
+  return path.resolve(baseUrl, filePath);
+};
+
+const createAliasMatcher = (baseUrl, alias) => {
+  const aliasPairs = Object.keys(alias).reduce((o, key) => {
+    if (isRegExpKey(key)) {
+      const regexp = new RegExp(key);
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([regexp, aliasPath]);
+    } else {
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([key, aliasPath]);
+    }
+
+    return o;
+  }, []);
+  return requestedModule => {
+    for (const [key, value] of aliasPairs) {
+      if (key instanceof RegExp) {
+        if (key.test(requestedModule)) {
+          return value;
+        }
+      }
+
+      if (requestedModule === key) {
+        return value;
+      }
+    }
+  };
+};
+
+export function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
+  const tsPaths = {};
+  const alias = {};
+  Object.keys(paths).forEach(key => {
+    if (Array.isArray(paths[key])) {
+      tsPaths[key] = paths[key];
+    } else {
+      alias[key] = paths[key];
+    }
+  });
+  const matchAliasPath = createAliasMatcher(baseUrl, alias);
+  const matchTsPath = createMatchPath(baseUrl, tsPaths, ['main']);
+
+  const matchPath = (requestedModule, readJSONSync, fileExists, extensions) => {
+    const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+
+    if (result) {
+      return result;
+    }
+
+    return matchAliasPath(requestedModule);
+  };
+
+  if (Object.keys(paths).length === 0) {
+    return undefined;
+  }
+
+  return ctx => {
+    return sf => {
+      const visitNode = node => {
+        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
+          try {
+            const importPathWithQuotes = node.moduleSpecifier && node.moduleSpecifier.getText();
+
+            if (!importPathWithQuotes) {
+              return node;
+            }
+
+            const text = importPathWithQuotes.substring(1, importPathWithQuotes.length - 1);
+            const result = getNotAliasedPath(sf, matchPath, text);
+
+            if (!result) {
+              return node;
+            }
+
+            const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
+            moduleSpecifier.parent = node.moduleSpecifier.parent;
+
+            if (tsBinary.isImportDeclaration(node)) {
+              return tsBinary.factory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+            } else {
+              return tsBinary.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+            }
+          } catch (_unused) {
+            return node;
+          }
+        }
+
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+
+      return tsBinary.visitNode(sf, visitNode);
+    };
+  };
+} // fork from https://github.com/nestjs/nest-cli/blob/HEAD/lib/compiler/hooks/tsconfig-paths.hook.ts
+
+function getNotAliasedPath(sf, matcher, text) {
+  let result = matcher(text, undefined, undefined, ['.ts', '.tsx', '.js', '.jsx']);
+
+  if (!result) {
+    return;
+  }
+
+  if (os.platform() === 'win32') {
+    result = result.replace(/\\/g, '/');
+  }
+
+  if (!path.isAbsolute(result)) {
+    try {
+      // Installed packages (node modules) should take precedence over root files with the same name.
+      // Ref: https://github.com/nestjs/nest-cli/issues/838
+      const packagePath = require.resolve(text, {
+        paths: [process.cwd(), ...module.paths]
+      });
+
+      if (packagePath) {
+        return text;
+      }
+    } catch (_unused2) {}
+  }
+
+  const resolvedPath = posix.relative(dirname(sf.fileName), result) || './';
+  return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
+}

package/dist/js/modern/compilers/typescript/typescript-loader.js

@@ -0,0 +1,32 @@
+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; }
+
+export class TypescriptLoader {
+  constructor({
+    appDirectory
+  }) {
+    _defineProperty(this, "tsBinary", void 0);
+
+    _defineProperty(this, "appDirectory", void 0);
+
+    this.appDirectory = appDirectory;
+  }
+
+  load() {
+    if (this.tsBinary) {
+      return this.tsBinary;
+    }
+
+    try {
+      const tsPath = require.resolve('typescript', {
+        paths: [this.appDirectory || process.cwd()]
+      });
+
+      const ts = require(tsPath);
+
+      return ts;
+    } catch (error) {
+      throw new Error('TypeScript could not be found! Please, install "typescript" package.');
+    }
+  }
+
+}

package/dist/js/modern/index.js

@@ -1 +1,2 @@
-export * from "./babel";
+export * from "./compilers/babel";
+export { compile } from "./common";

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.recursiveReadTsFiles = exports.compile = exports.TS_CONFIG_FILENAME = 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 compile = async (appDirectory, modernConfig, compileOptions) => {
+  const tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
+  const isTsProject = await _utils.fs.pathExists(tsConifgPath);
+
+  if (isTsProject) {
+    await (0, _typescript.compileByTs)(appDirectory, modernConfig, compileOptions);
+  } else {
+    await (0, _babel.compileByBabel)(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;

package/dist/js/node/{babel.js → compilers/babel/index.js}

@@ -7,14 +7,21 @@ var _exportNames = {
   readTsConfig: true,
   existTsConfigFile: true,
   getBabelConfig: true,
-  resolveBabelConfig: true
+  resolveBabelConfig: true,
+  compileByBabel: true
 };
-exports.resolveBabelConfig = exports.readTsConfig = exports.getBabelConfig = exports.existTsConfigFile = void 0;
+exports.resolveBabelConfig = exports.readTsConfig = exports.getBabelConfig = exports.existTsConfigFile = exports.compileByBabel = void 0;
+
+var path = _interopRequireWildcard(require("path"));
 
 var _babelPresetLib = require("@modern-js/babel-preset-lib");
 
 var _utils = require("@modern-js/utils");
 
+var _babelCompiler = require("@modern-js/babel-compiler");
+
+var _common = require("../../common");
+
 var _core = require("@babel/core");
 
 Object.keys(_core).forEach(function (key) {
@@ -29,6 +36,10 @@ Object.keys(_core).forEach(function (key) {
   });
 });
 
+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; }
+
 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; }
@@ -120,4 +131,44 @@ const resolveBabelConfig = (appDirectory, modernConfig, option // FIXME: babel t
   return (0, _babelPresetLib.applyUserBabelConfig)(internalBabelConfig, userBabelConfig);
 };
 
-exports.resolveBabelConfig = resolveBabelConfig;
+exports.resolveBabelConfig = resolveBabelConfig;
+
+const compileByBabel = async (appDirectory, modernConfig, compileOptions) => {
+  const {
+    patterns
+  } = compileOptions;
+  const results = await Promise.all(patterns.map(async pattern => {
+    const {
+      from,
+      to,
+      tsconfigPath
+    } = pattern;
+    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, {
+        filter: src => !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath
+      });
+    }
+
+    return (0, _babelCompiler.compiler)({
+      rootDir: appDirectory,
+      distDir: to,
+      sourceDir: from,
+      extensions: _common.FILE_EXTENSIONS
+    }, babelConfig);
+  }));
+  results.forEach(result => {
+    if (result.code === 1) {
+      throw new Error(result.message);
+    }
+  });
+};
+
+exports.compileByBabel = compileByBabel;

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

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compileByTs = void 0;
+
+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");
+
+var _typescript = _interopRequireDefault(require("typescript"));
+
+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; }
+
+const readTsConfigByFile = tsConfigFile => {
+  const parsedCmd = _typescript.default.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, _typescript.default.sys);
+
+  const {
+    options,
+    fileNames,
+    projectReferences
+  } = parsedCmd;
+  return {
+    options,
+    fileNames,
+    projectReferences
+  };
+};
+
+const copyFiles = async (from, to, tsconfigPath) => {
+  if (await _utils.fs.pathExists(from)) {
+    const basename = _path.default.basename(from);
+
+    const targetDir = _path.default.join(to, basename);
+
+    await _utils.fs.copy(from, targetDir, {
+      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
+  } = compileOptions;
+  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 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);
+  }
+};
+
+exports.compileByTs = compileByTs;
+
+const getFormatHost = ts => {
+  return {
+    getCanonicalFileName: path => path,
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getNewLine: () => ts.sys.newLine
+  };
+};