@modern-js/app-tools 3.1.3 → 3.1.5

package/dist/esm/utils/register.mjs

@@ -1,11 +1,57 @@
 import node_path from "node:path";
-import { fs, getAliasConfig, isDepExists, loadFromProject, readTsConfigByFile } from "@modern-js/utils";
+import { fs, getAliasConfig, isDepExists, loadFromProject, mergeAlias, readTsConfigByFile } from "@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 node_path.isAbsolute(normalizedValue) ? node_path.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 = 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 = {})=>{
@@ -14,32 +60,17 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
     const isTsProject = await fs.pathExists(tsconfigPath);
     const hasTsNode = 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 = 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 && node_path.isAbsolute(tsPath)) tsPath = node_path.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) {
@@ -47,7 +78,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 = readTsConfigByFile(tsconfigPath);
@@ -69,13 +107,8 @@ 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
-    });
 };
 export { resolveTsRuntimeRegisterMode, setupTsRuntime };

package/dist/esm-node/commands/dev.mjs

@@ -15,8 +15,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-node/esm/register-esm.mjs

@@ -1,11 +1,8 @@
 import "node:module";
 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;
@@ -14,10 +11,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-node/esm/ts-node-loader.mjs

@@ -1,18 +1,15 @@
 import "node:module";
 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-node/esm/ts-paths-loader.mjs

@@ -2,58 +2,36 @@ import "node:module";
 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-node/plugins/analyze/utils.mjs

@@ -2,8 +2,8 @@ import "node:module";
 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 [
@@ -22,13 +22,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-node/plugins/deploy/utils/generator.mjs

@@ -19,7 +19,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)=>[

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

@@ -1,13 +1,59 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import node_path from "node:path";
-import { fs, getAliasConfig, isDepExists, loadFromProject, readTsConfigByFile } from "@modern-js/utils";
+import { fs, getAliasConfig, isDepExists, loadFromProject, mergeAlias, readTsConfigByFile } from "@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 node_path.isAbsolute(normalizedValue) ? node_path.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 = 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 = {})=>{
@@ -16,32 +62,17 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
     const isTsProject = await fs.pathExists(tsconfigPath);
     const hasTsNode = 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 = 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 && node_path.isAbsolute(tsPath)) tsPath = node_path.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) {
@@ -49,7 +80,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 = readTsConfigByFile(tsconfigPath);
@@ -71,13 +109,8 @@ 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
-    });
 };
 export { resolveTsRuntimeRegisterMode, setupTsRuntime };

package/dist/types/esm/register-esm.d.mts

@@ -1,7 +1,8 @@
-export function registerModuleHooks({ appDir, distDir, alias }: {
+export function registerModuleHooks({ appDir, distDir, baseUrl, paths, }: {
     appDir: any;
     distDir: any;
-    alias: any;
+    baseUrl: any;
+    paths: any;
 }): Promise<void>;
 export function registerPathsLoader({ appDir, baseUrl, paths }: {
     appDir: any;

package/dist/types/esm/ts-node-loader.d.mts

@@ -1,7 +1,6 @@
-export function initialize({ appDir, alias, tsconfigPath }: {
-    appDir: any;
-    alias: any;
-    tsconfigPath: any;
+export function initialize({ baseUrl, paths }: {
+    baseUrl: any;
+    paths: any;
 }): Promise<void>;
 export function resolve(specifier: any, context: any, defaultResolve: any): any;
 export function load(url: any, context: any, defaultLoad: any): any;

package/dist/types/utils/register.d.ts

@@ -3,7 +3,6 @@ import type { ConfigChain } from '@rsbuild/core';
 type TsRuntimeRegisterMode = 'ts-node' | 'node-loader' | 'unsupported';
 interface TsRuntimeSetupOptions {
     moduleType?: string;
-    preferTsNodeForServerRuntime?: boolean;
 }
 export declare const resolveTsRuntimeRegisterMode: (hasTsNode: boolean) => TsRuntimeRegisterMode;
 /**

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.1.3",
+  "version": "3.1.5",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -83,30 +83,29 @@
     "@babel/parser": "^7.29.2",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@rsbuild/core": "2.0.0-rc.0",
+    "@rsbuild/core": "2.0.0",
+    "@swc/core": "1.15.11",
     "@swc/helpers": "^0.5.17",
     "es-module-lexer": "^1.7.0",
-    "esbuild": "0.25.5",
-    "esbuild-register": "^3.6.0",
     "import-meta-resolve": "^4.2.0",
     "flatted": "^3.4.2",
-    "mlly": "^1.8.0",
+    "mlly": "^1.8.2",
     "ndepe": "^0.1.13",
     "pkg-types": "^1.3.1",
     "std-env": "^3.10.0",
-    "@modern-js/builder": "3.1.3",
-    "@modern-js/i18n-utils": "3.1.3",
-    "@modern-js/plugin-data-loader": "3.1.3",
-    "@modern-js/plugin": "3.1.3",
-    "@modern-js/prod-server": "3.1.3",
-    "@modern-js/server": "3.1.3",
-    "@modern-js/server-core": "3.1.3",
-    "@modern-js/server-utils": "3.1.3",
-    "@modern-js/types": "3.1.3",
-    "@modern-js/utils": "3.1.3"
+    "@modern-js/builder": "3.1.5",
+    "@modern-js/i18n-utils": "3.1.5",
+    "@modern-js/prod-server": "3.1.5",
+    "@modern-js/plugin-data-loader": "3.1.5",
+    "@modern-js/plugin": "3.1.5",
+    "@modern-js/server": "3.1.5",
+    "@modern-js/server-core": "3.1.5",
+    "@modern-js/types": "3.1.5",
+    "@modern-js/server-utils": "3.1.5",
+    "@modern-js/utils": "3.1.5"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.0",
+    "@rslib/core": "0.21.2",
     "@types/babel__traverse": "7.28.0",
     "@types/node": "^20",
     "ts-node": "^10.9.2",

package/dist/cjs/esm/utils.js

@@ -1,69 +0,0 @@
-"use strict";
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    createMatchPath: ()=>createMatchPath
-});
-const external_module_namespaceObject = require("module");
-const external_path_namespaceObject = require("path");
-const utils_namespaceObject = require("@modern-js/utils");
-const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
-const utils_require = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
-function createMatchPath({ alias, appDir, tsconfigPath }) {
-    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 = utils_require.resolve(tsPath, {
-                paths: [
-                    appDir
-                ]
-            });
-        } catch  {}
-        if ('string' == typeof tsPath && external_path_namespaceObject.isAbsolute(tsPath)) tsPath = external_path_namespaceObject.relative(absoluteBaseUrl, tsPath);
-        if ('string' == typeof tsPath) tsPath = [
-            tsPath
-        ];
-        return {
-            ...o,
-            [`${key}`]: tsPath
-        };
-    }, {});
-    return (0, tsconfig_paths_namespaceObject.createMatchPath)(absoluteBaseUrl, tsPaths);
-}
-exports.createMatchPath = __webpack_exports__.createMatchPath;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createMatchPath"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/esm/utils.mjs

@@ -1,31 +0,0 @@
-import { createRequire } from 'module';
-import path from 'path';
-import { getAliasConfig } from '@modern-js/utils';
-import { createMatchPath as oCreateMatchPath } from '@modern-js/utils/tsconfig-paths';
-const require = createRequire(import.meta.url);
-export function createMatchPath({ alias, appDir, tsconfigPath }) {
-    const aliasConfig = 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: [
-                    appDir
-                ]
-            });
-        } catch  {}
-        if ('string' == typeof tsPath && path.isAbsolute(tsPath)) tsPath = path.relative(absoluteBaseUrl, tsPath);
-        if ('string' == typeof tsPath) tsPath = [
-            tsPath
-        ];
-        return {
-            ...o,
-            [`${key}`]: tsPath
-        };
-    }, {});
-    return oCreateMatchPath(absoluteBaseUrl, tsPaths);
-}