@modern-js/server-utils 2.60.0 → 2.60.1-alpha.0

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

@@ -52,7 +52,7 @@ const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
       filter: (src) => ![
         ".ts",
         ".js"
-      ].includes(import_path.default.extname(src)) && src !== tsconfigPath
+      ].includes(import_path.default.extname(src)) && src.endsWith("tsconfig.json")
     });
   }
 };

package/dist/common/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.FILE_EXTENSIONS = void 0;
+const path = __importStar(require("path"));
+const utils_1 = require("@modern-js/utils");
+exports.FILE_EXTENSIONS = ['.js', '.ts', '.mjs', '.ejs'];
+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 = (appDirectory, modernConfig, compileOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    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 = (_a = modernConfig === null || modernConfig === void 0 ? void 0 : modernConfig.server) === null || _a === void 0 ? void 0 : _a.compiler;
+    const isTsProject = tsconfigPath && (yield utils_1.fs.pathExists(tsconfigPath));
+    if (!isTsProject || compiler === 'babel') {
+        // eslint-disable-next-line node/file-extension-in-import
+        const { compileByBabel } = yield import('../compilers/babel/index.js');
+        yield compileByBabel(appDirectory, modernConfig, compileOptions);
+    }
+    else {
+        // eslint-disable-next-line node/file-extension-in-import
+        const { compileByTs } = yield import('../compilers/typescript/index.js');
+        yield compileByTs(appDirectory, modernConfig, compileOptions);
+    }
+});
+exports.compile = compile;

package/dist/compilers/babel/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileByBabel = exports.resolveBabelConfig = exports.existTsConfigFile = exports.readTsConfig = void 0;
+const path = __importStar(require("path"));
+const utils_1 = require("@modern-js/utils");
+const babel_compiler_1 = require("@modern-js/babel-compiler");
+const common_1 = require("../../common");
+const preset_1 = require("./preset");
+__exportStar(require("@babel/core"), exports);
+const readTsConfig = (tsconfigPath, noExistReturn = null) => {
+    // 如果不存在，则返回 noExistReturn
+    if (!utils_1.fs.existsSync(tsconfigPath)) {
+        return noExistReturn;
+    }
+    const content = utils_1.fs.readFileSync(tsconfigPath, 'utf-8');
+    return utils_1.json5.parse(content);
+};
+exports.readTsConfig = readTsConfig;
+const existTsConfigFile = (tsconfigAbsolutePath) => {
+    const tsconfig = (0, exports.readTsConfig)(tsconfigAbsolutePath);
+    return Boolean(tsconfig);
+};
+exports.existTsConfigFile = existTsConfigFile;
+const resolveBabelConfig = (appDirectory, config, option) => {
+    const { alias, babelConfig } = config;
+    // alias config
+    const aliasConfig = (0, utils_1.getAliasConfig)(alias, Object.assign({ appDirectory }, option));
+    // babel config
+    const defaultBabelConfig = (0, preset_1.getBabelConfig)({
+        appDirectory,
+        alias: aliasConfig,
+    });
+    return (0, preset_1.applyUserBabelConfig)(defaultBabelConfig, babelConfig);
+};
+exports.resolveBabelConfig = resolveBabelConfig;
+const compileByBabel = (appDirectory, config, compileOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    const results = yield Promise.all(sourceDirs.map((sourceDir) => __awaiter(void 0, void 0, void 0, function* () {
+        const babelConfig = (0, exports.resolveBabelConfig)(appDirectory, config, {
+            tsconfigPath: tsconfigPath ? tsconfigPath : '',
+        });
+        if (yield utils_1.fs.pathExists(sourceDir)) {
+            const basename = path.basename(sourceDir);
+            const targetDir = path.join(distDir, basename);
+            yield utils_1.fs.copy(sourceDir, targetDir, {
+                filter: src => !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath,
+            });
+        }
+        return (0, babel_compiler_1.compiler)({
+            rootDir: appDirectory,
+            distDir,
+            sourceDir,
+            extensions: common_1.FILE_EXTENSIONS,
+        }, babelConfig);
+    })));
+    results.forEach(result => {
+        if (result.code === 1) {
+            throw new Error(result.message);
+        }
+    });
+});
+exports.compileByBabel = compileByBabel;

package/dist/compilers/babel/preset/alias.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliasPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const tsconfig_paths_1 = require("@modern-js/utils/tsconfig-paths");
+const utils_1 = require("@modern-js/utils");
+const { resolvePath } = require('@modern-js/babel-plugin-module-resolver');
+const defaultPaths = { '@': ['./src'] };
+const aliasPlugin = (alias) => {
+    const { absoluteBaseUrl, isTsPath, isTsProject = false } = alias;
+    const mergedPaths = isTsPath
+        ? alias.paths || {}
+        : Object.assign(Object.assign({}, defaultPaths), (alias.paths || {}));
+    let tsPaths = {};
+    if (isTsProject) {
+        tsPaths = (0, utils_1.getUserAlias)(mergedPaths);
+    }
+    tsPaths = Object.keys(tsPaths).reduce((o, key) => {
+        if (typeof tsPaths[key] === 'string') {
+            return Object.assign(Object.assign({}, o), { [`${key}`]: [tsPaths[key]] });
+        }
+        return Object.assign(Object.assign({}, o), { [`${key}`]: tsPaths[key] });
+    }, {});
+    const resolvePathFn = (sourcePath, currentFile, opts) => {
+        // fix by: https://github.com/tleunen/babel-plugin-module-resolver/pull/409/files
+        if (sourcePath === '.' || sourcePath === './') {
+            return sourcePath;
+        }
+        /**
+         *以下是匹配到tsconfig的paths的情况进行进一步匹配和转换
+         */
+        const matchPath = (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, tsPaths, ['index']);
+        const result = matchPath(sourcePath, undefined, undefined, [
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+        ]);
+        if (result) {
+            const relativePath = path_1.default.relative(path_1.default.dirname(currentFile), path_1.default.dirname(result));
+            const fileName = path_1.default.basename(result);
+            // 如果是同级文件，则返回的是 ''
+            const filePath = path_1.default
+                .normalize(`${relativePath.length === 0 ? '.' : 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 : undefined,
+            extensions: isTsProject ? typescriptExts : undefined,
+        },
+    ];
+};
+exports.aliasPlugin = aliasPlugin;

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

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyUserBabelConfig = exports.getBabelConfig = void 0;
+const node_1 = require("@rsbuild/babel-preset/node");
+const alias_1 = require("./alias");
+const getBabelConfig = (libPresetOption) => {
+    var _a, _b, _c;
+    const config = (0, node_1.getBabelConfigForNode)({
+        presetEnv: {
+            loose: true,
+            modules: 'commonjs',
+        },
+        pluginDecorators: {
+            version: 'legacy',
+        },
+    });
+    (_a = config.presets) === null || _a === void 0 ? void 0 : _a.push([
+        require.resolve('@babel/preset-react'),
+        {
+            runtime: 'automatic',
+        },
+    ]);
+    if (libPresetOption.alias) {
+        (_b = config.plugins) === null || _b === void 0 ? void 0 : _b.push((0, alias_1.aliasPlugin)(libPresetOption.alias));
+    }
+    (_c = config.plugins) === null || _c === void 0 ? void 0 : _c.push(require.resolve('babel-plugin-transform-typescript-metadata'));
+    return config;
+};
+exports.getBabelConfig = getBabelConfig;
+__exportStar(require("./types"), exports);
+var utils_1 = require("@modern-js/utils");
+Object.defineProperty(exports, "applyUserBabelConfig", { enumerable: true, get: function () { return utils_1.applyUserBabelConfig; } });

package/dist/compilers/babel/preset/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compilers/typescript/index.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileByTs = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const typescriptLoader_1 = require("./typescriptLoader");
+const tsconfigPathsPlugin_1 = require("./tsconfigPathsPlugin");
+const readTsConfigByFile = (tsConfigFile, tsInstance) => {
+    const parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, tsInstance.sys);
+    const { options, fileNames, projectReferences } = parsedCmd;
+    return { options, fileNames, projectReferences };
+};
+const copyFiles = (from, to, appDirectory, tsconfigPath) => __awaiter(void 0, void 0, void 0, function* () {
+    if (yield utils_1.fs.pathExists(from)) {
+        const relativePath = path_1.default.relative(appDirectory, from);
+        const targetDir = path_1.default.join(to, relativePath);
+        yield utils_1.fs.copy(from, targetDir, {
+            filter: src => !['.ts'].includes(path_1.default.extname(src)) && src !== tsconfigPath,
+        });
+    }
+});
+const compileByTs = (appDirectory, config, compileOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    utils_1.logger.info(`Running ts compile...`);
+    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+    if (!tsconfigPath) {
+        return;
+    }
+    const ts = new typescriptLoader_1.TypescriptLoader({
+        appDirectory,
+    }).load();
+    const createProgram = ts.createIncrementalProgram || ts.createProgram;
+    const formatHost = getFormatHost(ts);
+    const { alias } = config;
+    const aliasOption = (0, utils_1.getAliasConfig)(alias, {
+        appDirectory,
+        tsconfigPath,
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
+    const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath, ts);
+    const sourcePosixPaths = sourceDirs.map(sourceDir => sourceDir.split(path_1.default.sep).join(path_1.default.posix.sep));
+    const rootNames = fileNames.filter(fileName => {
+        return (fileName.endsWith('.d.ts') ||
+            sourcePosixPaths.some(sourceDir => {
+                return fileName.includes(sourceDir);
+            }));
+    });
+    const program = createProgram.call(ts, {
+        rootNames,
+        projectReferences,
+        options: Object.assign({ rootDir: appDirectory, outDir: distDir }, options),
+    });
+    const tsconfigPathsPlugin = (0, tsconfigPathsPlugin_1.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
+    const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+        before: [tsconfigPathsPlugin],
+    });
+    const allDiagnostics = ts
+        .getPreEmitDiagnostics(program)
+        .concat(emitResult.diagnostics);
+    const { noEmitOnError } = options;
+    if (allDiagnostics.length > 0) {
+        utils_1.logger.error(ts.formatDiagnosticsWithColorAndContext([...new Set(allDiagnostics)], formatHost));
+        if (typeof noEmitOnError === 'undefined' || noEmitOnError === true) {
+            // eslint-disable-next-line no-process-exit
+            process.exit(1);
+        }
+    }
+    for (const source of sourceDirs) {
+        yield copyFiles(source, distDir, appDirectory, tsconfigPath);
+    }
+    utils_1.logger.info(`Ts compile succeed`);
+});
+exports.compileByTs = compileByTs;
+const getFormatHost = (ts) => {
+    return {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    };
+};

package/dist/compilers/typescript/tsconfigPathsPlugin.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsconfigPathsBeforeHookFactory = void 0;
+const os = __importStar(require("os"));
+const path_1 = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const tsconfig_paths_1 = require("@modern-js/utils/tsconfig-paths");
+const isRegExpKey = (str) => {
+    return str.startsWith('^') || str.endsWith('$');
+};
+const resolveAliasPath = (baseUrl, filePath) => {
+    // exclude absolute path and alias
+    if (filePath.startsWith('.') || filePath.startsWith('..')) {
+        return path_1.default.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();
+    // eslint-disable-next-line consistent-return
+    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) => {
+    return (tsBinary.isCallExpression(node) &&
+        node.expression.kind === ts.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 = (0, tsconfig_paths_1.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) => {
+                var _a;
+                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 = (_a = node === null || node === void 0 ? void 0 : node.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.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;
+                        if (tsBinary.isImportDeclaration(node)) {
+                            newNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+                        }
+                        else {
+                            newNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+                        }
+                        newNode.flags = node.flags;
+                        return newNode;
+                    }
+                    catch (_b) {
+                        return node;
+                    }
+                }
+                return tsBinary.visitEachChild(node, visitNode, ctx);
+            };
+            return tsBinary.visitNode(sf, visitNode);
+        };
+    };
+}
+exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
+// fork from https://github.com/nestjs/nest-cli/blob/HEAD/lib/compiler/hooks/tsconfig-paths.hook.ts
+// license at https://github.com/nestjs/nest/blob/master/LICENSE
+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_1.default.isAbsolute(result)) {
+        // handle alias to alias
+        if (!result.startsWith('.') && !result.startsWith('..')) {
+            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(result, {
+                    paths: [process.cwd(), ...module.paths],
+                });
+                if (packagePath) {
+                    // eslint-disable-next-line consistent-return
+                    return result;
+                }
+            }
+            catch (_a) { }
+        }
+        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) {
+                // eslint-disable-next-line consistent-return
+                return text;
+            }
+        }
+        catch (_b) { }
+    }
+    const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
+    // eslint-disable-next-line consistent-return
+    return resolvedPath[0] === '.' ? resolvedPath : `./${resolvedPath}`;
+}

package/dist/compilers/typescript/typescriptLoader.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypescriptLoader = void 0;
+class TypescriptLoader {
+    constructor({ appDirectory }) {
+        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.');
+        }
+    }
+}
+exports.TypescriptLoader = TypescriptLoader;

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

@@ -40,7 +40,7 @@ var copyFiles = function() {
                 return ![
                   ".ts",
                   ".js"
-                ].includes(path.extname(src)) && src !== tsconfigPath;
+                ].includes(path.extname(src)) && src.endsWith("tsconfig.json");
               }
             })
           ];

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

@@ -19,7 +19,7 @@ const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
       filter: (src) => ![
         ".ts",
         ".js"
-      ].includes(path.extname(src)) && src !== tsconfigPath
+      ].includes(path.extname(src)) && src.endsWith("tsconfig.json")
     });
   }
 };

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+__exportStar(require("./compilers/babel"), exports);
+var common_1 = require("./common");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return common_1.compile; } });
+__exportStar(require("./utils"), exports);

package/dist/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireExistModuleAsync = exports.compatRequireAsync = void 0;
+const utils_1 = require("@modern-js/utils");
+const compatRequireAsync = (filePath, interop = true) => __awaiter(void 0, void 0, void 0, function* () {
+    if (filePath.endsWith('.json')) {
+        return require(filePath);
+    }
+    try {
+        const mod = require(filePath);
+        const rtnESMDefault = interop && (mod === null || mod === void 0 ? void 0 : mod.__esModule);
+        return rtnESMDefault ? mod.default : mod;
+    }
+    catch (error) {
+        if (error.code === 'ERR_REQUIRE_ESM') {
+            return yield import(filePath);
+        }
+        else {
+            throw error;
+        }
+    }
+});
+exports.compatRequireAsync = compatRequireAsync;
+const requireExistModuleAsync = (filename, opt) => __awaiter(void 0, void 0, void 0, function* () {
+    const final = Object.assign({ extensions: ['.ts', '.js'], interop: true }, opt);
+    const exist = (0, utils_1.findExists)(final.extensions.map(ext => `${filename}${ext}`));
+    if (!exist) {
+        return null;
+    }
+    return yield (0, exports.compatRequireAsync)(exist, final.interop);
+});
+exports.requireExistModuleAsync = requireExistModuleAsync;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.60.0",
+  "version": "2.60.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -39,9 +39,9 @@
     "@swc/helpers": "0.5.13",
     "babel-plugin-transform-typescript-metadata": "^0.3.2",
     "@modern-js/babel-compiler": "2.60.0",
+    "@modern-js/utils": "2.60.0",
     "@modern-js/babel-preset": "2.60.0",
-    "@modern-js/babel-plugin-module-resolver": "2.60.0",
-    "@modern-js/utils": "2.60.0"
+    "@modern-js/babel-plugin-module-resolver": "2.60.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
@@ -50,8 +50,8 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@modern-js/server-core": "2.60.0",
     "@scripts/build": "2.60.0",
+    "@modern-js/server-core": "2.60.0",
     "@scripts/jest-config": "2.60.0"
   },
   "sideEffects": false,