@bleedingdev/modern-js-server-utils 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

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

@@ -3,8 +3,11 @@ const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/
 import { fs, getAliasConfig, logger } from "@modern-js/utils";
 import { spawn } from "child_process";
 import path from "path";
+import { rewriteImportSpecifiers } from "./importRewriter.mjs";
 import { createTsconfigPathsMatcher, getNotAliasedPath } from "./tsconfigPathsPlugin.mjs";
-const importSpecifierRE = /((?:from\s*|import\s*\(\s*|require\s*\(\s*)['"])([^'"]+)(['"])/g;
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var typescript_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const copyFiles = async (from, to, appDirectory)=>{
     if (await fs.pathExists(from)) {
         const relativePath = path.relative(appDirectory, from);
@@ -17,42 +20,58 @@ const copyFiles = async (from, to, appDirectory)=>{
         });
     }
 };
-const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs)=>{
-    const output = await runTsgo([
+let resolvedConfigCount = 0;
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs, moduleType, tsgoBinPath)=>{
+    const tsconfigDir = path.dirname(tsconfigPath);
+    const output = await runTsgo(tsgoBinPath, [
         '--showConfig',
         '-p',
         tsconfigPath
     ], {
-        cwd: path.dirname(tsconfigPath)
+        cwd: tsconfigDir
     });
     const config = JSON.parse(output.stdout);
     config.compilerOptions ??= {};
     config.compilerOptions.rootDir = appDirectory;
     config.compilerOptions.outDir = distDir;
-    config.files = filterSourceFiles(appDirectory, sourceDirs, config.files);
+    config.files = filterSourceFiles(tsconfigDir, sourceDirs, config.files);
     delete config.include;
     delete config.compilerOptions.baseUrl;
     if ([
         'node',
         'node10'
     ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
-    const resolvedConfigPath = path.join(appDirectory, `.tsgo.${process.pid}.resolved.json`);
+    if ('module' !== moduleType) {
+        if ([
+            'preserve',
+            'esnext',
+            'es2015',
+            'es2020',
+            'es2022',
+            'es6'
+        ].includes(String(config.compilerOptions.module).toLowerCase())) {
+            config.compilerOptions.module = 'commonjs';
+            delete config.compilerOptions.moduleResolution;
+        }
+        config.compilerOptions.verbatimModuleSyntax = false;
+    }
+    const resolvedConfigPath = path.join(tsconfigDir, `.tsgo.${process.pid}.${resolvedConfigCount++}.resolved.json`);
     await fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
     return {
         config,
         resolvedConfigPath
     };
 };
-const filterSourceFiles = (appDirectory, sourceDirs, files = [])=>{
+const filterSourceFiles = (tsconfigDir, sourceDirs, files = [])=>{
     const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path.sep).join(path.posix.sep));
     return files.filter((fileName)=>{
-        const absoluteFileName = path.resolve(appDirectory, fileName).split(path.sep).join(path.posix.sep);
+        const absoluteFileName = path.resolve(tsconfigDir, fileName).split(path.sep).join(path.posix.sep);
         return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
     });
 };
-const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
+const runTsgo = (tsgoBinPath, args, options)=>new Promise((resolve, reject)=>{
         const child = spawn(process.execPath, [
-            getTsgoBinPath(),
+            tsgoBinPath,
             ...args
         ], {
             cwd: options.cwd,
@@ -81,14 +100,51 @@ const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
             resolve(result);
         });
     });
-const getTsgoBinPath = ()=>path.join(path.dirname(require.resolve("@typescript/native-preview/package.json")), 'bin/tsgo.js');
+const getTsgoBinPath = (appDirectory, resolvePaths = [
+    appDirectory,
+    typescript_dirname
+])=>{
+    try {
+        const pkgPath = require.resolve("@typescript/native-preview/package.json", {
+            paths: resolvePaths
+        });
+        return path.join(path.dirname(pkgPath), 'bin/tsgo.js');
+    } catch  {
+        throw new Error('tsgo could not be found! Please install "@typescript/native-preview" in your project to compile BFF/server code.');
+    }
+};
+const OUTPUT_SOURCE_EXTENSIONS = {
+    '.js': [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx'
+    ],
+    '.mjs': [
+        '.mts',
+        '.mjs'
+    ],
+    '.cjs': [
+        '.cts',
+        '.cjs'
+    ]
+};
 const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
     const relativeOutput = path.relative(distDir, outputFile);
     const parsed = path.parse(relativeOutput);
     const sourceBase = path.join(appDirectory, parsed.dir, parsed.name);
-    return findExistingSource(`${sourceBase}.ts`) || findExistingSource(`${sourceBase}.tsx`) || findExistingSource(`${sourceBase}.js`) || findExistingSource(`${sourceBase}.jsx`);
+    const extensions = OUTPUT_SOURCE_EXTENSIONS[parsed.ext] ?? OUTPUT_SOURCE_EXTENSIONS['.js'];
+    for (const extension of extensions){
+        const candidate = `${sourceBase}${extension}`;
+        if (fs.existsSync(candidate)) return candidate;
+    }
+};
+const sourceMappingUrlRE = /^\/\/[#@] sourceMappingURL=.*$/gm;
+const dropStaleSourceMap = async (outputFile, content)=>{
+    const mapFile = `${outputFile}.map`;
+    if (await fs.pathExists(mapFile)) await fs.remove(mapFile);
+    return content.replace(sourceMappingUrlRE, '');
 };
-const findExistingSource = (filePath)=>fs.existsSync(filePath) ? filePath : void 0;
 const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
     if (0 === Object.keys(paths).length || !await fs.pathExists(distDir)) return;
     const matcher = createTsconfigPathsMatcher(baseUrl, paths);
@@ -98,14 +154,8 @@ const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, mo
         const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
         if (!sourceFile) return;
         const content = await fs.readFile(file, 'utf8');
-        let changed = false;
-        const rewritten = content.replace(importSpecifierRE, (match, prefix, specifier, suffix)=>{
-            const nextSpecifier = getNotAliasedPath(sourceFile, matcher, specifier, moduleType);
-            if (!nextSpecifier || nextSpecifier === specifier) return match;
-            changed = true;
-            return `${prefix}${nextSpecifier}${suffix}`;
-        });
-        if (changed) await fs.writeFile(file, rewritten);
+        const { content: rewritten, changed } = rewriteImportSpecifiers(content, (specifier)=>getNotAliasedPath(sourceFile, matcher, specifier, moduleType));
+        if (changed) await fs.writeFile(file, await dropStaleSourceMap(file, rewritten));
     }));
 };
 const collectOutputFiles = async (dir)=>{
@@ -131,24 +181,34 @@ const compileByTs = async (appDirectory, config, compileOptions)=>{
         tsconfigPath
     });
     const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
-    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs);
-    const result = await runTsgo([
-        '-p',
-        resolvedConfigPath
-    ], {
-        cwd: appDirectory,
-        reject: false
-    });
-    await fs.remove(resolvedConfigPath);
+    const tsgoBinPath = getTsgoBinPath(appDirectory);
+    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs, compileOptions.moduleType, tsgoBinPath);
+    let result;
+    try {
+        result = await runTsgo(tsgoBinPath, [
+            '-p',
+            resolvedConfigPath
+        ], {
+            cwd: appDirectory,
+            reject: false
+        });
+    } finally{
+        await fs.remove(resolvedConfigPath);
+    }
     if (result.stderr) logger.error(result.stderr);
     if (result.stdout) logger.info(result.stdout);
     if (0 !== result.code) {
         const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
-        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) logger.error('TS-Go compilation failed');
-        else process.exit(1);
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) {
+            logger.error('TS-Go compilation failed');
+            throw new Error([
+                `TS-Go compilation failed with exit code ${result.code}.`,
+                result.stderr.trim() || result.stdout.trim()
+            ].filter(Boolean).join('\n'));
+        } else process.exit(1);
     }
     await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
     for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
     logger.info("TS-Go compile succeed");
 };
-export { compileByTs };
+export { compileByTs, createResolvedTsgoConfig, getTsgoBinPath, rewriteOutputSpecifiers };

package/dist/types/compilers/typescript/importRewriter.d.ts

@@ -0,0 +1,12 @@
+export type SpecifierRewrite = (specifier: string) => string | undefined;
+/**
+ * Rewrite the import/export/require specifiers of emitted JavaScript.
+ *
+ * Specifiers whose contents contain escape sequences are left untouched (the
+ * raw source slice would not round-trip), which never happens for the
+ * compiler-emitted relative/alias specifiers this is used on.
+ */
+export declare const rewriteImportSpecifiers: (content: string, rewrite: SpecifierRewrite) => {
+    content: string;
+    changed: boolean;
+};

package/dist/types/compilers/typescript/index.d.ts

@@ -1,2 +1,22 @@
 import type { CompileFunc } from '../../common';
+type TsgoConfig = {
+    compilerOptions?: {
+        baseUrl?: unknown;
+        module?: string;
+        moduleResolution?: string;
+        noEmitOnError?: boolean;
+        outDir?: string;
+        rootDir?: string;
+        verbatimModuleSyntax?: boolean;
+    };
+    files?: string[];
+    include?: string[];
+};
+export declare const createResolvedTsgoConfig: (appDirectory: string, tsconfigPath: string, distDir: string, sourceDirs: string[], moduleType: 'module' | 'commonjs' | undefined, tsgoBinPath: string) => Promise<{
+    config: TsgoConfig;
+    resolvedConfigPath: string;
+}>;
+export declare const getTsgoBinPath: (appDirectory: string, resolvePaths?: string[]) => string;
+export declare const rewriteOutputSpecifiers: (appDirectory: string, distDir: string, baseUrl: string, paths: Record<string, string[] | string>, moduleType?: 'module' | 'commonjs') => Promise<void>;
 export declare const compileByTs: CompileFunc;
+export {};

package/dist/types/compilers/typescript/tsconfigPathsPlugin.d.ts

@@ -1,3 +1,3 @@
 import type { MatchPath } from '@modern-js/utils/tsconfig-paths';
 export declare const createTsconfigPathsMatcher: (baseUrl: string, paths: Record<string, string[] | string>) => MatchPath | undefined;
-export declare function getNotAliasedPath(sourceFile: string, matcher: MatchPath, text: string, moduleType?: 'module' | 'commonjs'): any;
+export declare function getNotAliasedPath(sourceFile: string, matcher: MatchPath, text: string, moduleType?: 'module' | 'commonjs'): string | undefined;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.99",
+  "version": "3.4.0-ultramodern.1",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -40,14 +40,22 @@
   },
   "dependencies": {
     "@swc/helpers": "^0.5.23",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.99"
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.1"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.5",
-    "@types/node": "^25.9.1",
-    "@typescript/native-preview": "7.0.0-dev.20260527.2",
-    "@scripts/rstest-config": "2.66.0",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.99"
+    "@rslib/core": "0.23.0",
+    "@types/node": "^26.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260624.1",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.1",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "peerDependencies": {
+    "@typescript/native-preview": ">=7.0.0-dev.20260624.1"
+  },
+  "peerDependenciesMeta": {
+    "@typescript/native-preview": {
+      "optional": true
+    }
   },
   "sideEffects": false,
   "publishConfig": {