@modern-js/app-tools 3.1.3 → 3.1.4

package/dist/cjs/commands/dev.js

@@ -52,8 +52,7 @@ const dev = async (api, options, devServerOptions)=>{
     const hooks = api.getHooks();
     const combinedAlias = [].concat(normalizedConfig?.resolve?.alias ?? []).concat(normalizedConfig?.source?.alias ?? []);
     await (0, register_js_namespaceObject.setupTsRuntime)(appContext.appDirectory, appContext.distDirectory, combinedAlias, {
-        moduleType: appContext.moduleType,
-        preferTsNodeForServerRuntime: true
+        moduleType: appContext.moduleType
     });
     const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
     const meta = (0, utils_namespaceObject.getMeta)(metaName);

package/dist/cjs/esm/register-esm.js

@@ -31,12 +31,9 @@ __webpack_require__.d(__webpack_exports__, {
     registerPathsLoader: ()=>registerPathsLoader
 });
 const external_node_path_namespaceObject = require("node:path");
-const utils_namespaceObject = require("@modern-js/utils");
-const registerModuleHooks = async ({ appDir, distDir, alias })=>{
+const registerModuleHooks = async ({ appDir, distDir, baseUrl, paths })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = external_node_path_namespaceObject.resolve(appDir, TS_CONFIG_FILENAME);
-    const hasTsconfig = await utils_namespaceObject.fs.pathExists(tsconfigPath);
-    if (!hasTsconfig) return;
     const { register } = await import("node:module");
     process.env.TS_NODE_TRANSPILE_ONLY = true;
     process.env.TS_NODE_PROJECT = tsconfigPath;
@@ -45,10 +42,8 @@ const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${external_node_path_namespaceObject.relative(appDir, distDir)}/`;
     register('./ts-node-loader.mjs', __rslib_import_meta_url__, {
         data: {
-            appDir,
-            distDir,
-            alias,
-            tsconfigPath
+            baseUrl,
+            paths
         }
     });
 };

package/dist/cjs/esm/register-esm.mjs

@@ -1,10 +1,7 @@
 import path from 'node:path';
-import { fs } from '@modern-js/utils';
-export const registerModuleHooks = async ({ appDir, distDir, alias })=>{
+export const registerModuleHooks = async ({ appDir, distDir, baseUrl, paths })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
-    const hasTsconfig = await fs.pathExists(tsconfigPath);
-    if (!hasTsconfig) return;
     const { register } = await import('node:module');
     process.env.TS_NODE_TRANSPILE_ONLY = true;
     process.env.TS_NODE_PROJECT = tsconfigPath;
@@ -13,10 +10,8 @@ export const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(appDir, distDir)}/`;
     register('./ts-node-loader.mjs', import.meta.url, {
         data: {
-            appDir,
-            distDir,
-            alias,
-            tsconfigPath
+            baseUrl,
+            paths
         }
     });
 };

package/dist/cjs/esm/ts-node-loader.js

@@ -29,19 +29,16 @@ __webpack_require__.d(__webpack_exports__, {
     resolve: ()=>resolve
 });
 const external_url_namespaceObject = require("url");
+const utils_namespaceObject = require("@modern-js/utils");
+const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
 const esm_namespaceObject = require("ts-node/esm");
-const external_utils_js_namespaceObject = require("./utils.js");
 let matchPath;
-async function initialize({ appDir, alias, tsconfigPath }) {
-    matchPath = (0, external_utils_js_namespaceObject.createMatchPath)({
-        alias,
-        appDir,
-        tsconfigPath
-    });
+async function initialize({ baseUrl, paths }) {
+    matchPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl || './', paths || {});
 }
 function resolve(specifier, context, defaultResolve) {
-    const match = matchPath(specifier);
-    return match ? (0, esm_namespaceObject.resolve)((0, external_url_namespaceObject.pathToFileURL)(match).href, context, defaultResolve) : (0, esm_namespaceObject.resolve)(specifier, context, defaultResolve);
+    const match = (0, utils_namespaceObject.findMatchedSourcePath)(matchPath, specifier);
+    return match ? (0, esm_namespaceObject.resolve)((0, external_url_namespaceObject.pathToFileURL)((0, utils_namespaceObject.findSourceEntry)(match) || match).href, context, defaultResolve) : (0, esm_namespaceObject.resolve)(specifier, context, defaultResolve);
 }
 function load(url, context, defaultLoad) {
     const filePath = new URL(url).pathname;

package/dist/cjs/esm/ts-node-loader.mjs

@@ -1,18 +1,15 @@
 import { pathToFileURL } from 'url';
+import { findMatchedSourcePath, findSourceEntry } from '@modern-js/utils';
+import { createMatchPath } from '@modern-js/utils/tsconfig-paths';
 import { resolve as tsNodeResolve } from 'ts-node/esm';
 import { load as tsNodeLoad } from 'ts-node/esm';
-import { createMatchPath } from './utils.mjs';
 let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-    matchPath = createMatchPath({
-        alias,
-        appDir,
-        tsconfigPath
-    });
+export async function initialize({ baseUrl, paths }) {
+    matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 export function resolve(specifier, context, defaultResolve) {
-    const match = matchPath(specifier);
-    return match ? tsNodeResolve(pathToFileURL(match).href, context, defaultResolve) : tsNodeResolve(specifier, context, defaultResolve);
+    const match = findMatchedSourcePath(matchPath, specifier);
+    return match ? tsNodeResolve(pathToFileURL(findSourceEntry(match) || match).href, context, defaultResolve) : tsNodeResolve(specifier, context, defaultResolve);
 }
 export function load(url, context, defaultLoad) {
     const filePath = new URL(url).pathname;

package/dist/cjs/esm/ts-paths-loader.js

@@ -30,58 +30,36 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 const external_url_namespaceObject = require("url");
+const utils_namespaceObject = require("@modern-js/utils");
 const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
 let matchPath;
 let appDir;
-const resolvePathWithExtensions = (matchedPath)=>{
-    if (external_node_path_namespaceObject.extname(matchedPath)) return matchedPath;
-    const fileCandidates = [
-        matchedPath,
-        `${matchedPath}.ts`,
-        `${matchedPath}.tsx`,
-        `${matchedPath}.mts`,
-        `${matchedPath}.cts`,
-        `${matchedPath}.js`,
-        `${matchedPath}.mjs`,
-        `${matchedPath}.cjs`
-    ];
-    for (const candidate of fileCandidates)if (external_node_fs_namespaceObject.existsSync(candidate) && external_node_fs_namespaceObject.statSync(candidate).isFile()) return candidate;
-    const indexCandidates = [
-        external_node_path_namespaceObject.join(matchedPath, 'index.ts'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.tsx'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.mts'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.cts'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.js'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.mjs'),
-        external_node_path_namespaceObject.join(matchedPath, 'index.cjs')
-    ];
-    for (const candidate of indexCandidates)if (external_node_fs_namespaceObject.existsSync(candidate) && external_node_fs_namespaceObject.statSync(candidate).isFile()) return candidate;
-    return matchedPath;
+const getParentPath = (parentURL)=>{
+    if (!parentURL) return process.cwd();
+    if (external_node_path_namespaceObject.isAbsolute(parentURL)) return external_node_path_namespaceObject.dirname(parentURL);
+    try {
+        const url = new URL(parentURL);
+        if ('file:' === url.protocol) return external_node_path_namespaceObject.dirname((0, external_url_namespaceObject.fileURLToPath)(url));
+    } catch  {}
+    return process.cwd();
 };
 async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
     appDir = external_node_path_namespaceObject.resolve(currentAppDir);
     matchPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl || './', paths || {});
 }
 function resolve(specifier, context, defaultResolve) {
-    const parentPath = context.parentURL ? external_node_path_namespaceObject.dirname((0, external_url_namespaceObject.fileURLToPath)(context.parentURL)) : process.cwd();
+    const parentPath = getParentPath(context.parentURL);
     const relativeFromApp = appDir ? external_node_path_namespaceObject.relative(appDir, parentPath) : '';
     const isAppFile = appDir && (parentPath === appDir || relativeFromApp && !relativeFromApp.startsWith('..') && !external_node_path_namespaceObject.isAbsolute(relativeFromApp));
     if ((specifier.startsWith('./') || specifier.startsWith('../')) && !external_node_path_namespaceObject.extname(specifier) && isAppFile) {
-        const resolvedPath = resolvePathWithExtensions(external_node_path_namespaceObject.resolve(parentPath, specifier));
+        const matchedPath = external_node_path_namespaceObject.resolve(parentPath, specifier);
+        const resolvedPath = (0, utils_namespaceObject.findSourceEntry)(matchedPath) || matchedPath;
         if (resolvedPath && external_node_fs_namespaceObject.existsSync(resolvedPath)) return defaultResolve((0, external_url_namespaceObject.pathToFileURL)(resolvedPath).href, context, defaultResolve);
     }
     if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
-    const match = matchPath(specifier, void 0, void 0, [
-        '.ts',
-        '.tsx',
-        '.mts',
-        '.cts',
-        '.js',
-        '.mjs',
-        '.cjs'
-    ]);
+    const match = (0, utils_namespaceObject.findMatchedSourcePath)(matchPath, specifier);
     if (!match) return defaultResolve(specifier, context, defaultResolve);
-    const resolvedPath = resolvePathWithExtensions(match);
+    const resolvedPath = (0, utils_namespaceObject.findSourceEntry)(match) || match;
     return defaultResolve((0, external_url_namespaceObject.pathToFileURL)(resolvedPath).href, context, defaultResolve);
 }
 exports.initialize = __webpack_exports__.initialize;

package/dist/cjs/esm/ts-paths-loader.mjs

@@ -1,57 +1,35 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { findMatchedSourcePath, findSourceEntry } from '@modern-js/utils';
 import { createMatchPath as oCreateMatchPath } from '@modern-js/utils/tsconfig-paths';
 let matchPath;
 let appDir;
-const resolvePathWithExtensions = (matchedPath)=>{
-    if (path.extname(matchedPath)) return matchedPath;
-    const fileCandidates = [
-        matchedPath,
-        `${matchedPath}.ts`,
-        `${matchedPath}.tsx`,
-        `${matchedPath}.mts`,
-        `${matchedPath}.cts`,
-        `${matchedPath}.js`,
-        `${matchedPath}.mjs`,
-        `${matchedPath}.cjs`
-    ];
-    for (const candidate of fileCandidates)if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
-    const indexCandidates = [
-        path.join(matchedPath, 'index.ts'),
-        path.join(matchedPath, 'index.tsx'),
-        path.join(matchedPath, 'index.mts'),
-        path.join(matchedPath, 'index.cts'),
-        path.join(matchedPath, 'index.js'),
-        path.join(matchedPath, 'index.mjs'),
-        path.join(matchedPath, 'index.cjs')
-    ];
-    for (const candidate of indexCandidates)if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
-    return matchedPath;
+const getParentPath = (parentURL)=>{
+    if (!parentURL) return process.cwd();
+    if (path.isAbsolute(parentURL)) return path.dirname(parentURL);
+    try {
+        const url = new URL(parentURL);
+        if ('file:' === url.protocol) return path.dirname(fileURLToPath(url));
+    } catch  {}
+    return process.cwd();
 };
 export async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
     appDir = path.resolve(currentAppDir);
     matchPath = oCreateMatchPath(baseUrl || './', paths || {});
 }
 export function resolve(specifier, context, defaultResolve) {
-    const parentPath = context.parentURL ? path.dirname(fileURLToPath(context.parentURL)) : process.cwd();
+    const parentPath = getParentPath(context.parentURL);
     const relativeFromApp = appDir ? path.relative(appDir, parentPath) : '';
     const isAppFile = appDir && (parentPath === appDir || relativeFromApp && !relativeFromApp.startsWith('..') && !path.isAbsolute(relativeFromApp));
     if ((specifier.startsWith('./') || specifier.startsWith('../')) && !path.extname(specifier) && isAppFile) {
-        const resolvedPath = resolvePathWithExtensions(path.resolve(parentPath, specifier));
+        const matchedPath = path.resolve(parentPath, specifier);
+        const resolvedPath = findSourceEntry(matchedPath) || matchedPath;
         if (resolvedPath && fs.existsSync(resolvedPath)) return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
     }
     if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
-    const match = matchPath(specifier, void 0, void 0, [
-        '.ts',
-        '.tsx',
-        '.mts',
-        '.cts',
-        '.js',
-        '.mjs',
-        '.cjs'
-    ]);
+    const match = findMatchedSourcePath(matchPath, specifier);
     if (!match) return defaultResolve(specifier, context, defaultResolve);
-    const resolvedPath = resolvePathWithExtensions(match);
+    const resolvedPath = findSourceEntry(match) || match;
     return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
 }

package/dist/cjs/plugins/analyze/utils.js

@@ -46,8 +46,8 @@ var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namesp
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
+const core_namespaceObject = require("@swc/core");
 const external_es_module_lexer_namespaceObject = require("es-module-lexer");
-const external_esbuild_namespaceObject = require("esbuild");
 const walkDirectory = (dir)=>external_fs_default().readdirSync(dir).reduce((previous, filename)=>{
         const filePath = external_path_default().join(dir, filename);
         if (external_fs_default().statSync(filePath).isDirectory()) return [
@@ -66,13 +66,30 @@ const replaceWithAlias = (base, filePath, alias)=>{
 const parseModule = async ({ source, filename })=>{
     let content = source;
     if (utils_namespaceObject.JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
-        const result = await (0, external_esbuild_namespaceObject.transform)(content, {
-            loader: external_path_default().extname(filename).slice(1),
-            format: 'esm',
-            tsconfigRaw: {
-                compilerOptions: {
-                    experimentalDecorators: true
-                }
+        const ext = external_path_default().extname(filename);
+        const isTs = '.ts' === ext || '.tsx' === ext;
+        const isJsx = '.jsx' === ext || '.tsx' === ext;
+        const result = await (0, core_namespaceObject.transform)(content, {
+            filename,
+            isModule: true,
+            module: {
+                type: 'es6'
+            },
+            jsc: {
+                parser: isTs ? {
+                    syntax: "typescript",
+                    tsx: isJsx,
+                    decorators: true
+                } : {
+                    syntax: "ecmascript",
+                    jsx: isJsx,
+                    decorators: true
+                },
+                transform: {
+                    legacyDecorator: true
+                },
+                target: 'es2022',
+                keepClassNames: true
             }
         });
         content = result.code;

package/dist/cjs/plugins/deploy/utils/generator.js

@@ -60,7 +60,7 @@ const genPluginImportsCode = (plugins, isESM = false)=>plugins.map(([name, optio
         return `${im};const plugin_${index} = plugin_${index}_ns.default || plugin_${index}_ns`;
     }).join(';\n');
 const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
-const getServerConfigPath = (meta)=>`"${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().join(utils_namespaceObject.SERVER_DIR, `${meta}.server`))}"`;
+const getServerConfigPath = (meta)=>`path.join(__dirname, "${utils_namespaceObject.SERVER_DIR}", "${meta}.server")`;
 const generateHandler = async ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate = serverAppContextTemplate, genPluginImports = genPluginImportsCode, isESM })=>{
     const { serverPlugins, metaName } = appContext;
     const plugins = serverPlugins.map((plugin)=>[

package/dist/cjs/utils/register.js

@@ -39,12 +39,58 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
+const normalizePathValue = ({ key, value, absoluteBaseUrl })=>{
+    let normalizedValue = value;
+    if (key.startsWith('@') && normalizedValue.startsWith('@')) try {
+        normalizedValue = require.resolve(normalizedValue, {
+            paths: [
+                process.cwd(),
+                ...module.paths
+            ]
+        });
+    } catch  {}
+    return external_node_path_default().isAbsolute(normalizedValue) ? external_node_path_default().relative(absoluteBaseUrl, normalizedValue) : normalizedValue;
+};
+const normalizePathValues = ({ key, value, absoluteBaseUrl })=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return values.map((item)=>normalizePathValue({
+            key,
+            value: item,
+            absoluteBaseUrl
+        }));
+};
+const addResolvedAlias = (paths, key, values)=>{
+    if (!key || paths[key]) return;
+    paths[key] = values;
+};
+const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
+    const mergedAlias = (0, utils_namespaceObject.mergeAlias)(alias);
+    const normalizedPaths = Object.keys(paths).reduce((result, key)=>{
+        addResolvedAlias(result, key.endsWith('$') ? key.slice(0, -1) : key, normalizePathValues({
+            key,
+            value: paths[key],
+            absoluteBaseUrl
+        }));
+        return result;
+    }, {});
+    Object.keys(mergedAlias).forEach((key)=>{
+        if (key.includes('*') || key.endsWith('$')) return;
+        addResolvedAlias(normalizedPaths, `${key}/*`, normalizePathValues({
+            key,
+            value: mergedAlias[key],
+            absoluteBaseUrl
+        }).map((value)=>`${value}/*`));
+    });
+    return normalizedPaths;
+};
 const resolveTsRuntimeRegisterMode = (hasTsNode)=>{
+    if (hasTsNode) return 'ts-node';
     const hasNativeTypeScriptSupport = process.features?.typescript;
     const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
     const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
     if (supportsNativeTypeScript) return 'node-loader';
-    if (hasTsNode) return 'ts-node';
     return 'unsupported';
 };
 const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
@@ -53,32 +99,17 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
     const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
     const hasTsNode = (0, utils_namespaceObject.isDepExists)(appDir, 'ts-node');
     if (!isTsProject) return;
-    const preferredRegisterMode = resolveTsRuntimeRegisterMode(hasTsNode);
-    const registerMode = options.preferTsNodeForServerRuntime && hasTsNode ? 'ts-node' : preferredRegisterMode;
+    const registerMode = resolveTsRuntimeRegisterMode(hasTsNode);
     const aliasConfig = (0, utils_namespaceObject.getAliasConfig)(alias, {
         appDirectory: appDir,
         tsconfigPath
     });
     const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
-    const tsPaths = Object.keys(paths).reduce((o, key)=>{
-        let tsPath = paths[key];
-        if ('string' == typeof tsPath && key.startsWith('@') && tsPath.startsWith('@')) try {
-            tsPath = require.resolve(tsPath, {
-                paths: [
-                    process.cwd(),
-                    ...module.paths
-                ]
-            });
-        } catch  {}
-        if ('string' == typeof tsPath && external_node_path_default().isAbsolute(tsPath)) tsPath = external_node_path_default().relative(absoluteBaseUrl, tsPath);
-        if ('string' == typeof tsPath) tsPath = [
-            tsPath
-        ];
-        return {
-            ...o,
-            [`${key}`]: tsPath
-        };
-    }, {});
+    const runtimePaths = createRuntimePaths({
+        alias,
+        paths,
+        absoluteBaseUrl
+    });
     if ('unsupported' === registerMode) return;
     if ('ts-node' === registerMode) {
         if ('module' === options.moduleType) {
@@ -86,7 +117,14 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
             await registerModuleHooks({
                 appDir,
                 distDir,
-                alias: alias || {}
+                baseUrl: absoluteBaseUrl || './',
+                paths: runtimePaths
+            });
+        } else {
+            const { register } = await import("@modern-js/utils/tsconfig-paths");
+            register({
+                baseUrl: absoluteBaseUrl || './',
+                paths: runtimePaths
             });
         }
         const tsConfig = (0, utils_namespaceObject.readTsConfigByFile)(tsconfigPath);
@@ -108,14 +146,9 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
         await registerPathsLoader({
             appDir,
             baseUrl: absoluteBaseUrl || './',
-            paths: tsPaths
+            paths: runtimePaths
         });
     }
-    const { register } = await import("@modern-js/utils/tsconfig-paths");
-    register({
-        baseUrl: absoluteBaseUrl || './',
-        paths: tsPaths
-    });
 };
 exports.resolveTsRuntimeRegisterMode = __webpack_exports__.resolveTsRuntimeRegisterMode;
 exports.setupTsRuntime = __webpack_exports__.setupTsRuntime;

package/dist/esm/commands/dev.mjs

@@ -14,8 +14,7 @@ const dev = async (api, options, devServerOptions)=>{
     const hooks = api.getHooks();
     const combinedAlias = [].concat(normalizedConfig?.resolve?.alias ?? []).concat(normalizedConfig?.source?.alias ?? []);
     await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias, {
-        moduleType: appContext.moduleType,
-        preferTsNodeForServerRuntime: true
+        moduleType: appContext.moduleType
     });
     const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
     const meta = getMeta(metaName);

package/dist/esm/esm/register-esm.mjs

@@ -1,10 +1,7 @@
 import node_path from "node:path";
-import { fs } from "@modern-js/utils";
-const registerModuleHooks = async ({ appDir, distDir, alias })=>{
+const registerModuleHooks = async ({ appDir, distDir, baseUrl, paths })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
-    const hasTsconfig = await fs.pathExists(tsconfigPath);
-    if (!hasTsconfig) return;
     const { register } = await import("node:module");
     process.env.TS_NODE_TRANSPILE_ONLY = true;
     process.env.TS_NODE_PROJECT = tsconfigPath;
@@ -13,10 +10,8 @@ const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${node_path.relative(appDir, distDir)}/`;
     register('./ts-node-loader.mjs', import.meta.url, {
         data: {
-            appDir,
-            distDir,
-            alias,
-            tsconfigPath
+            baseUrl,
+            paths
         }
     });
 };

package/dist/esm/esm/ts-node-loader.mjs

@@ -1,17 +1,14 @@
 import { pathToFileURL } from "url";
+import { findMatchedSourcePath, findSourceEntry } from "@modern-js/utils";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
 import { load, resolve } from "ts-node/esm";
-import { createMatchPath } from "./utils.mjs";
 let matchPath;
-async function initialize({ appDir, alias, tsconfigPath }) {
-    matchPath = createMatchPath({
-        alias,
-        appDir,
-        tsconfigPath
-    });
+async function initialize({ baseUrl, paths }) {
+    matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 function ts_node_loader_resolve(specifier, context, defaultResolve) {
-    const match = matchPath(specifier);
-    return match ? resolve(pathToFileURL(match).href, context, defaultResolve) : resolve(specifier, context, defaultResolve);
+    const match = findMatchedSourcePath(matchPath, specifier);
+    return match ? resolve(pathToFileURL(findSourceEntry(match) || match).href, context, defaultResolve) : resolve(specifier, context, defaultResolve);
 }
 function ts_node_loader_load(url, context, defaultLoad) {
     const filePath = new URL(url).pathname;

package/dist/esm/esm/ts-paths-loader.mjs

@@ -1,58 +1,36 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
+import { findMatchedSourcePath, findSourceEntry } from "@modern-js/utils";
 import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
 let matchPath;
 let appDir;
-const resolvePathWithExtensions = (matchedPath)=>{
-    if (node_path.extname(matchedPath)) return matchedPath;
-    const fileCandidates = [
-        matchedPath,
-        `${matchedPath}.ts`,
-        `${matchedPath}.tsx`,
-        `${matchedPath}.mts`,
-        `${matchedPath}.cts`,
-        `${matchedPath}.js`,
-        `${matchedPath}.mjs`,
-        `${matchedPath}.cjs`
-    ];
-    for (const candidate of fileCandidates)if (node_fs.existsSync(candidate) && node_fs.statSync(candidate).isFile()) return candidate;
-    const indexCandidates = [
-        node_path.join(matchedPath, 'index.ts'),
-        node_path.join(matchedPath, 'index.tsx'),
-        node_path.join(matchedPath, 'index.mts'),
-        node_path.join(matchedPath, 'index.cts'),
-        node_path.join(matchedPath, 'index.js'),
-        node_path.join(matchedPath, 'index.mjs'),
-        node_path.join(matchedPath, 'index.cjs')
-    ];
-    for (const candidate of indexCandidates)if (node_fs.existsSync(candidate) && node_fs.statSync(candidate).isFile()) return candidate;
-    return matchedPath;
+const getParentPath = (parentURL)=>{
+    if (!parentURL) return process.cwd();
+    if (node_path.isAbsolute(parentURL)) return node_path.dirname(parentURL);
+    try {
+        const url = new URL(parentURL);
+        if ('file:' === url.protocol) return node_path.dirname(fileURLToPath(url));
+    } catch  {}
+    return process.cwd();
 };
 async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
     appDir = node_path.resolve(currentAppDir);
     matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 function resolve(specifier, context, defaultResolve) {
-    const parentPath = context.parentURL ? node_path.dirname(fileURLToPath(context.parentURL)) : process.cwd();
+    const parentPath = getParentPath(context.parentURL);
     const relativeFromApp = appDir ? node_path.relative(appDir, parentPath) : '';
     const isAppFile = appDir && (parentPath === appDir || relativeFromApp && !relativeFromApp.startsWith('..') && !node_path.isAbsolute(relativeFromApp));
     if ((specifier.startsWith('./') || specifier.startsWith('../')) && !node_path.extname(specifier) && isAppFile) {
-        const resolvedPath = resolvePathWithExtensions(node_path.resolve(parentPath, specifier));
+        const matchedPath = node_path.resolve(parentPath, specifier);
+        const resolvedPath = findSourceEntry(matchedPath) || matchedPath;
         if (resolvedPath && node_fs.existsSync(resolvedPath)) return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
     }
     if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
-    const match = matchPath(specifier, void 0, void 0, [
-        '.ts',
-        '.tsx',
-        '.mts',
-        '.cts',
-        '.js',
-        '.mjs',
-        '.cjs'
-    ]);
+    const match = findMatchedSourcePath(matchPath, specifier);
     if (!match) return defaultResolve(specifier, context, defaultResolve);
-    const resolvedPath = resolvePathWithExtensions(match);
+    const resolvedPath = findSourceEntry(match) || match;
     return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
 }
 export { initialize, resolve };

package/dist/esm/plugins/analyze/utils.mjs

@@ -1,8 +1,8 @@
 import fs from "fs";
 import path from "path";
 import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
+import { transform } from "@swc/core";
 import { parse } from "es-module-lexer";
-import { transform } from "esbuild";
 const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
         const filePath = path.join(dir, filename);
         if (fs.statSync(filePath).isDirectory()) return [
@@ -21,13 +21,30 @@ const replaceWithAlias = (base, filePath, alias)=>{
 const parseModule = async ({ source, filename })=>{
     let content = source;
     if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const ext = path.extname(filename);
+        const isTs = '.ts' === ext || '.tsx' === ext;
+        const isJsx = '.jsx' === ext || '.tsx' === ext;
         const result = await transform(content, {
-            loader: path.extname(filename).slice(1),
-            format: 'esm',
-            tsconfigRaw: {
-                compilerOptions: {
-                    experimentalDecorators: true
-                }
+            filename,
+            isModule: true,
+            module: {
+                type: 'es6'
+            },
+            jsc: {
+                parser: isTs ? {
+                    syntax: "typescript",
+                    tsx: isJsx,
+                    decorators: true
+                } : {
+                    syntax: "ecmascript",
+                    jsx: isJsx,
+                    decorators: true
+                },
+                transform: {
+                    legacyDecorator: true
+                },
+                target: 'es2022',
+                keepClassNames: true
             }
         });
         content = result.code;

package/dist/esm/plugins/deploy/utils/generator.mjs

@@ -18,7 +18,7 @@ const genPluginImportsCode = (plugins, isESM = false)=>plugins.map(([name, optio
         return `${im};const plugin_${index} = plugin_${index}_ns.default || plugin_${index}_ns`;
     }).join(';\n');
 const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
-const getServerConfigPath = (meta)=>`"${normalizePath(node_path.join(SERVER_DIR, `${meta}.server`))}"`;
+const getServerConfigPath = (meta)=>`path.join(__dirname, "${SERVER_DIR}", "${meta}.server")`;
 const generateHandler = async ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate = serverAppContextTemplate, genPluginImports = genPluginImportsCode, isESM })=>{
     const { serverPlugins, metaName } = appContext;
     const plugins = serverPlugins.map((plugin)=>[