@modern-js/server-utils 2.69.4 → 3.0.0-alpha.0

package/dist/esm/compilers/babel/preset/alias.mjs

@@ -0,0 +1,84 @@
+import * as __rspack_external__modern_js_babel_plugin_module_resolver_fc5e2536 from "@modern-js/babel-plugin-module-resolver";
+import path from "path";
+import { getUserAlias } from "@modern-js/utils";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+var __webpack_modules__ = {
+    "@modern-js/babel-plugin-module-resolver" (module) {
+        module.exports = __rspack_external__modern_js_babel_plugin_module_resolver_fc5e2536;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { resolvePath } = __webpack_require__("@modern-js/babel-plugin-module-resolver");
+const defaultPaths = {
+    '@': [
+        './src'
+    ]
+};
+const aliasPlugin = (alias)=>{
+    const { absoluteBaseUrl, isTsPath, isTsProject = false } = alias;
+    const mergedPaths = isTsPath ? alias.paths || {} : {
+        ...defaultPaths,
+        ...alias.paths || {}
+    };
+    let tsPaths = {};
+    if (isTsProject) tsPaths = getUserAlias(mergedPaths);
+    tsPaths = Object.keys(tsPaths).reduce((o, key)=>{
+        if ('string' == typeof tsPaths[key]) return {
+            ...o,
+            [`${key}`]: [
+                tsPaths[key]
+            ]
+        };
+        return {
+            ...o,
+            [`${key}`]: tsPaths[key]
+        };
+    }, {});
+    const resolvePathFn = (sourcePath, currentFile, opts)=>{
+        if ('.' === sourcePath || './' === sourcePath) return sourcePath;
+        const matchPath = createMatchPath(absoluteBaseUrl, tsPaths, [
+            'index'
+        ]);
+        const result = matchPath(sourcePath, void 0, void 0, [
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx'
+        ]);
+        if (result) {
+            const relativePath = path.relative(path.dirname(currentFile), path.dirname(result));
+            const fileName = path.basename(result);
+            const filePath = path.normalize(`${0 === relativePath.length ? '.' : relativePath}/${fileName}`).replace(/\\/, '/');
+            return filePath.startsWith('.') ? filePath : `./${filePath}`;
+        }
+        return resolvePath(sourcePath, currentFile, opts);
+    };
+    const typescriptExts = [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '.es',
+        '.es6',
+        '.mjs'
+    ];
+    return [
+        require.resolve('@modern-js/babel-plugin-module-resolver'),
+        {
+            root: absoluteBaseUrl,
+            alias: mergedPaths,
+            resolvePath: isTsPath ? resolvePathFn : void 0,
+            extensions: isTsProject ? typescriptExts : void 0
+        }
+    ];
+};
+export { aliasPlugin };

package/dist/esm/compilers/babel/preset/index.mjs

@@ -0,0 +1,29 @@
+import { getBabelConfigForNode } from "@modern-js/babel-preset/node";
+import { aliasPlugin } from "./alias";
+import { applyUserBabelConfig } from "@modern-js/utils";
+export * from "./types";
+const getBabelConfig = (libPresetOption)=>{
+    const { isEsm } = libPresetOption;
+    const config = getBabelConfigForNode({
+        presetEnv: {
+            loose: true,
+            modules: isEsm ? false : 'commonjs',
+            targets: [
+                'node >= 14'
+            ]
+        },
+        pluginDecorators: {
+            version: 'legacy'
+        }
+    });
+    config.presets?.push([
+        require.resolve('@babel/preset-react'),
+        {
+            runtime: 'automatic'
+        }
+    ]);
+    if (libPresetOption.alias) config.plugins?.push(aliasPlugin(libPresetOption.alias));
+    config.plugins?.push(require.resolve("babel-plugin-transform-typescript-metadata"));
+    return config;
+};
+export { applyUserBabelConfig, getBabelConfig };

package/dist/esm/compilers/typescript/index.mjs

@@ -0,0 +1,76 @@
+import path_0 from "path";
+import { fs, getAliasConfig, logger } from "@modern-js/utils";
+import { tsconfigPathsBeforeHookFactory } from "./tsconfigPathsPlugin";
+import { TypescriptLoader } from "./typescriptLoader";
+const readTsConfigByFile = (tsConfigFile, tsInstance)=>{
+    const parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
+    const { options, fileNames, projectReferences } = parsedCmd;
+    return {
+        options,
+        fileNames,
+        projectReferences
+    };
+};
+const copyFiles = async (from, to, appDirectory)=>{
+    if (await fs.pathExists(from)) {
+        const relativePath = path_0.relative(appDirectory, from);
+        const targetDir = path_0.join(to, relativePath);
+        await fs.copy(from, targetDir, {
+            filter: (src)=>![
+                    '.ts',
+                    '.js'
+                ].includes(path_0.extname(src)) && !src.endsWith('tsconfig.json')
+        });
+    }
+};
+const compileByTs = async (appDirectory, config, compileOptions)=>{
+    logger.info("Running ts compile...");
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) return;
+    const ts = new TypescriptLoader({
+        appDirectory
+    }).load();
+    const createProgram = ts.createIncrementalProgram || ts.createProgram;
+    const formatHost = getFormatHost(ts);
+    const { alias } = config;
+    const aliasOption = getAliasConfig(alias, {
+        appDirectory,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath, ts);
+    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path_0.sep).join(path_0.posix.sep));
+    const rootNames = fileNames.filter((fileName)=>fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>fileName.includes(sourceDir)));
+    const program = createProgram.call(ts, {
+        rootNames,
+        projectReferences,
+        options: {
+            rootDir: appDirectory,
+            outDir: distDir,
+            ...options
+        }
+    });
+    const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+    const emitResult = program.emit(void 0, void 0, void 0, void 0, {
+        before: [
+            tsconfigPathsPlugin
+        ]
+    });
+    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+    const { noEmitOnError } = options;
+    if (allDiagnostics.length > 0) {
+        logger.error(ts.formatDiagnosticsWithColorAndContext([
+            ...new Set(allDiagnostics)
+        ], formatHost));
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) logger.error('TypeScript compilation failed');
+        else process.exit(1);
+    }
+    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    logger.info("Ts compile succeed");
+};
+const getFormatHost = (ts)=>({
+        getCanonicalFileName: (path)=>path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: ()=>ts.sys.newLine
+    });
+export { compileByTs };

package/dist/esm/compilers/typescript/tsconfigPathsPlugin.mjs

@@ -0,0 +1,126 @@
+import { platform } from "os";
+import path, { dirname, posix } from "path";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+import { SyntaxKind } from "typescript";
+const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
+const resolveAliasPath = (baseUrl, filePath)=>{
+    if (filePath.startsWith('.') || filePath.startsWith('..')) return path.resolve(baseUrl, filePath);
+    return 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;
+    }, []);
+    const cacheMap = new Map();
+    return (requestedModule)=>{
+        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
+        for (const [key, value] of aliasPairs){
+            if (key instanceof RegExp) {
+                if (key.test(requestedModule)) {
+                    cacheMap.set(requestedModule, value);
+                    return value;
+                }
+            }
+            if (requestedModule === key) {
+                cacheMap.set(requestedModule, value);
+                return value;
+            }
+        }
+    };
+};
+const isDynamicImport = (tsBinary, node)=>tsBinary.isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword;
+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 (0 === Object.keys(paths).length) return;
+    return (ctx)=>(sf)=>{
+            const visitNode = (node)=>{
+                if (isDynamicImport(tsBinary, node)) {
+                    const importPathWithQuotes = node.arguments[0].getText(sf);
+                    const text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
+                    const result = getNotAliasedPath(sf, matchPath, text);
+                    if (!result) return node;
+                    return tsBinary.factory.updateCallExpression(node, node.expression, node.typeArguments, tsBinary.factory.createNodeArray([
+                        tsBinary.factory.createStringLiteral(result)
+                    ]));
+                }
+                if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) try {
+                    const importPathWithQuotes = 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;
+                    let newNode;
+                    newNode = tsBinary.isImportDeclaration(node) ? tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause) : tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+                    newNode.flags = node.flags;
+                    return newNode;
+                } catch  {
+                    return node;
+                }
+                return tsBinary.visitEachChild(node, visitNode, ctx);
+            };
+            return tsBinary.visitNode(sf, visitNode);
+        };
+}
+function getNotAliasedPath(sf, matcher, text) {
+    let result = matcher(text, void 0, void 0, [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx'
+    ]);
+    if (!result) return;
+    if ('win32' === platform()) result = result.replace(/\\/g, '/');
+    if (!path.isAbsolute(result)) {
+        if (!result.startsWith('.') && !result.startsWith('..')) try {
+            const packagePath = require.resolve(result, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return result;
+        } catch  {}
+        try {
+            const packagePath = require.resolve(text, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+            if (packagePath) return text;
+        } catch  {}
+    }
+    const resolvedPath = posix.relative(dirname(sf.fileName), result) || './';
+    return '.' === resolvedPath[0] ? resolvedPath : `./${resolvedPath}`;
+}
+export { tsconfigPathsBeforeHookFactory };

package/dist/esm/compilers/typescript/typescriptLoader.mjs

@@ -0,0 +1,20 @@
+class TypescriptLoader {
+    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.');
+        }
+    }
+    constructor({ appDirectory }){
+        this.appDirectory = appDirectory;
+    }
+}
+export { TypescriptLoader };

package/dist/{esm-node/index.js → esm/index.mjs}

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

package/dist/esm-node/common/index.mjs

@@ -0,0 +1,29 @@
+import { isAbsolute } from "path";
+import { fs } from "@modern-js/utils";
+const FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs',
+    '.ejs'
+];
+const validateAbsolutePath = (filename, message)=>{
+    if (!isAbsolute(filename)) throw new Error(message);
+};
+const validateAbsolutePaths = (filenames, messageFunc)=>{
+    filenames.forEach((filename)=>validateAbsolutePath(filename, messageFunc(filename)));
+};
+const compile = async (appDirectory, modernConfig, compileOptions)=>{
+    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 compiler = modernConfig?.server?.compiler;
+    const isTsProject = tsconfigPath && await fs.pathExists(tsconfigPath);
+    if (isTsProject && 'babel' !== compiler) {
+        const { compileByTs } = await import("../compilers/typescript/index.mjs");
+        await compileByTs(appDirectory, modernConfig, compileOptions);
+    } else {
+        const { compileByBabel } = await import("../compilers/babel/index.mjs");
+        await compileByBabel(appDirectory, modernConfig, compileOptions);
+    }
+};
+export { FILE_EXTENSIONS, compile };

package/dist/esm-node/compilers/babel/index.mjs

@@ -0,0 +1,57 @@
+import { basename as external_path_basename, extname, join } from "path";
+import { compiler } from "@modern-js/babel-compiler";
+import { fs, getAliasConfig, json5 } from "@modern-js/utils";
+import { FILE_EXTENSIONS } from "../../common/index.mjs";
+import { applyUserBabelConfig, getBabelConfig } from "./preset/index.mjs";
+export * from "@babel/core";
+const readTsConfig = (tsconfigPath, noExistReturn = null)=>{
+    if (!fs.existsSync(tsconfigPath)) return noExistReturn;
+    const content = fs.readFileSync(tsconfigPath, 'utf-8');
+    return json5.parse(content);
+};
+const existTsConfigFile = (tsconfigAbsolutePath)=>{
+    const tsconfig = readTsConfig(tsconfigAbsolutePath);
+    return Boolean(tsconfig);
+};
+const resolveBabelConfig = (appDirectory, config, option, isEsm)=>{
+    const { alias, babelConfig } = config;
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory,
+        ...option
+    });
+    const defaultBabelConfig = getBabelConfig({
+        appDirectory,
+        alias: aliasConfig,
+        isEsm
+    });
+    return applyUserBabelConfig(defaultBabelConfig, babelConfig);
+};
+const compileByBabel = async (appDirectory, config, compileOptions)=>{
+    const { sourceDirs, distDir, tsconfigPath, moduleType } = compileOptions;
+    const isEsm = 'module' === moduleType;
+    const results = await Promise.all(sourceDirs.map(async (sourceDir)=>{
+        const babelConfig = resolveBabelConfig(appDirectory, config, {
+            tsconfigPath: tsconfigPath ? tsconfigPath : ''
+        }, isEsm);
+        if (await fs.pathExists(sourceDir)) {
+            const basename = external_path_basename(sourceDir);
+            const targetDir = join(distDir, basename);
+            await fs.copy(sourceDir, targetDir, {
+                filter: (src)=>![
+                        '.ts',
+                        '.js'
+                    ].includes(extname(src)) && src !== tsconfigPath
+            });
+        }
+        return compiler({
+            rootDir: appDirectory,
+            distDir,
+            sourceDir,
+            extensions: FILE_EXTENSIONS
+        }, babelConfig);
+    }));
+    results.forEach((result)=>{
+        if (1 === result.code) throw new Error(result.message);
+    });
+};
+export { compileByBabel, existTsConfigFile, readTsConfig, resolveBabelConfig };

package/dist/esm-node/compilers/babel/preset/alias.mjs

@@ -0,0 +1,84 @@
+import * as __rspack_external__modern_js_babel_plugin_module_resolver_fc5e2536 from "@modern-js/babel-plugin-module-resolver";
+import path from "path";
+import { getUserAlias } from "@modern-js/utils";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+var __webpack_modules__ = {
+    "@modern-js/babel-plugin-module-resolver" (module) {
+        module.exports = __rspack_external__modern_js_babel_plugin_module_resolver_fc5e2536;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { resolvePath } = __webpack_require__("@modern-js/babel-plugin-module-resolver");
+const defaultPaths = {
+    '@': [
+        './src'
+    ]
+};
+const aliasPlugin = (alias)=>{
+    const { absoluteBaseUrl, isTsPath, isTsProject = false } = alias;
+    const mergedPaths = isTsPath ? alias.paths || {} : {
+        ...defaultPaths,
+        ...alias.paths || {}
+    };
+    let tsPaths = {};
+    if (isTsProject) tsPaths = getUserAlias(mergedPaths);
+    tsPaths = Object.keys(tsPaths).reduce((o, key)=>{
+        if ('string' == typeof tsPaths[key]) return {
+            ...o,
+            [`${key}`]: [
+                tsPaths[key]
+            ]
+        };
+        return {
+            ...o,
+            [`${key}`]: tsPaths[key]
+        };
+    }, {});
+    const resolvePathFn = (sourcePath, currentFile, opts)=>{
+        if ('.' === sourcePath || './' === sourcePath) return sourcePath;
+        const matchPath = createMatchPath(absoluteBaseUrl, tsPaths, [
+            'index'
+        ]);
+        const result = matchPath(sourcePath, void 0, void 0, [
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx'
+        ]);
+        if (result) {
+            const relativePath = path.relative(path.dirname(currentFile), path.dirname(result));
+            const fileName = path.basename(result);
+            const filePath = path.normalize(`${0 === relativePath.length ? '.' : relativePath}/${fileName}`).replace(/\\/, '/');
+            return filePath.startsWith('.') ? filePath : `./${filePath}`;
+        }
+        return resolvePath(sourcePath, currentFile, opts);
+    };
+    const typescriptExts = [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '.es',
+        '.es6',
+        '.mjs'
+    ];
+    return [
+        require.resolve('@modern-js/babel-plugin-module-resolver'),
+        {
+            root: absoluteBaseUrl,
+            alias: mergedPaths,
+            resolvePath: isTsPath ? resolvePathFn : void 0,
+            extensions: isTsProject ? typescriptExts : void 0
+        }
+    ];
+};
+export { aliasPlugin };

package/dist/esm-node/compilers/babel/preset/index.mjs

@@ -0,0 +1,29 @@
+import { getBabelConfigForNode } from "@modern-js/babel-preset/node";
+import { aliasPlugin } from "./alias.mjs";
+import { applyUserBabelConfig } from "@modern-js/utils";
+export * from "./types.mjs";
+const getBabelConfig = (libPresetOption)=>{
+    const { isEsm } = libPresetOption;
+    const config = getBabelConfigForNode({
+        presetEnv: {
+            loose: true,
+            modules: isEsm ? false : 'commonjs',
+            targets: [
+                'node >= 14'
+            ]
+        },
+        pluginDecorators: {
+            version: 'legacy'
+        }
+    });
+    config.presets?.push([
+        require.resolve('@babel/preset-react'),
+        {
+            runtime: 'automatic'
+        }
+    ]);
+    if (libPresetOption.alias) config.plugins?.push(aliasPlugin(libPresetOption.alias));
+    config.plugins?.push(require.resolve("babel-plugin-transform-typescript-metadata"));
+    return config;
+};
+export { applyUserBabelConfig, getBabelConfig };

package/dist/esm-node/compilers/typescript/index.mjs

@@ -0,0 +1,76 @@
+import path_0 from "path";
+import { fs, getAliasConfig, logger } from "@modern-js/utils";
+import { tsconfigPathsBeforeHookFactory } from "./tsconfigPathsPlugin.mjs";
+import { TypescriptLoader } from "./typescriptLoader.mjs";
+const readTsConfigByFile = (tsConfigFile, tsInstance)=>{
+    const parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
+    const { options, fileNames, projectReferences } = parsedCmd;
+    return {
+        options,
+        fileNames,
+        projectReferences
+    };
+};
+const copyFiles = async (from, to, appDirectory)=>{
+    if (await fs.pathExists(from)) {
+        const relativePath = path_0.relative(appDirectory, from);
+        const targetDir = path_0.join(to, relativePath);
+        await fs.copy(from, targetDir, {
+            filter: (src)=>![
+                    '.ts',
+                    '.js'
+                ].includes(path_0.extname(src)) && !src.endsWith('tsconfig.json')
+        });
+    }
+};
+const compileByTs = async (appDirectory, config, compileOptions)=>{
+    logger.info("Running ts compile...");
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) return;
+    const ts = new TypescriptLoader({
+        appDirectory
+    }).load();
+    const createProgram = ts.createIncrementalProgram || ts.createProgram;
+    const formatHost = getFormatHost(ts);
+    const { alias } = config;
+    const aliasOption = getAliasConfig(alias, {
+        appDirectory,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath, ts);
+    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path_0.sep).join(path_0.posix.sep));
+    const rootNames = fileNames.filter((fileName)=>fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>fileName.includes(sourceDir)));
+    const program = createProgram.call(ts, {
+        rootNames,
+        projectReferences,
+        options: {
+            rootDir: appDirectory,
+            outDir: distDir,
+            ...options
+        }
+    });
+    const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+    const emitResult = program.emit(void 0, void 0, void 0, void 0, {
+        before: [
+            tsconfigPathsPlugin
+        ]
+    });
+    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+    const { noEmitOnError } = options;
+    if (allDiagnostics.length > 0) {
+        logger.error(ts.formatDiagnosticsWithColorAndContext([
+            ...new Set(allDiagnostics)
+        ], formatHost));
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) logger.error('TypeScript compilation failed');
+        else process.exit(1);
+    }
+    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    logger.info("Ts compile succeed");
+};
+const getFormatHost = (ts)=>({
+        getCanonicalFileName: (path)=>path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: ()=>ts.sys.newLine
+    });
+export { compileByTs };