@bleedingdev/modern-js-server-utils 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

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

@@ -0,0 +1,204 @@
+const IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;
+const WHITESPACE = /\s/;
+const KEYWORDS_BEFORE_REGEX = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await'
+]);
+const PUNCTUATORS_BEFORE_REGEX = new Set('{}(,;[=:?!&|+-*%^~<>/');
+const isRegexAllowed = (lastToken)=>{
+    if (!lastToken) return true;
+    if (KEYWORDS_BEFORE_REGEX.has(lastToken)) return true;
+    return 1 === lastToken.length && PUNCTUATORS_BEFORE_REGEX.has(lastToken);
+};
+const isSpecifierContext = (prev1, prev2, prev3)=>{
+    if (('from' === prev1 || 'import' === prev1) && '.' !== prev2) return true;
+    return '(' === prev1 && ('import' === prev2 || 'require' === prev2) && '.' !== prev3;
+};
+const skipRegexLiteral = (content, start)=>{
+    let i = start + 1;
+    let inClass = false;
+    while(i < content.length){
+        const ch = content[i];
+        if ('\\' === ch) {
+            i += 2;
+            continue;
+        }
+        if ('\n' === ch) break;
+        if ('[' === ch) inClass = true;
+        else if (']' === ch) inClass = false;
+        else if ('/' === ch && !inClass) {
+            i++;
+            while(i < content.length && IDENTIFIER_CHAR.test(content[i]))i++;
+            break;
+        }
+        i++;
+    }
+    return i;
+};
+const scanSpecifiers = (content)=>{
+    const specifiers = [];
+    const length = content.length;
+    const templateExpressionDepths = [];
+    let prev1 = '';
+    let prev2 = '';
+    let prev3 = '';
+    const pushToken = (token)=>{
+        prev3 = prev2;
+        prev2 = prev1;
+        prev1 = token;
+    };
+    let mode = 'code';
+    let i = 0;
+    while(i < length){
+        const ch = content[i];
+        if ('template' === mode) {
+            if ('\\' === ch) {
+                i += 2;
+                continue;
+            }
+            if ('`' === ch) {
+                mode = 'code';
+                pushToken('`');
+                i++;
+                continue;
+            }
+            if ('$' === ch && '{' === content[i + 1]) {
+                templateExpressionDepths.push(0);
+                mode = 'code';
+                pushToken('{');
+                i += 2;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (WHITESPACE.test(ch)) {
+            i++;
+            continue;
+        }
+        if ('/' === ch) {
+            const next = content[i + 1];
+            if ('/' === next) {
+                const newline = content.indexOf('\n', i + 2);
+                i = -1 === newline ? length : newline + 1;
+                continue;
+            }
+            if ('*' === next) {
+                const end = content.indexOf('*/', i + 2);
+                i = -1 === end ? length : end + 2;
+                continue;
+            }
+            if (isRegexAllowed(prev1)) {
+                i = skipRegexLiteral(content, i);
+                pushToken('/regex/');
+                continue;
+            }
+            pushToken('/');
+            i++;
+            continue;
+        }
+        if ('`' === ch) {
+            mode = 'template';
+            i++;
+            continue;
+        }
+        if ('{' === ch) {
+            if (templateExpressionDepths.length > 0) templateExpressionDepths[templateExpressionDepths.length - 1]++;
+            pushToken('{');
+            i++;
+            continue;
+        }
+        if ('}' === ch) {
+            if (templateExpressionDepths.length > 0) {
+                const top = templateExpressionDepths.length - 1;
+                if (0 === templateExpressionDepths[top]) {
+                    templateExpressionDepths.pop();
+                    mode = 'template';
+                    i++;
+                    continue;
+                }
+                templateExpressionDepths[top]--;
+            }
+            pushToken('}');
+            i++;
+            continue;
+        }
+        if ('"' === ch || "'" === ch) {
+            const start = i;
+            let j = i + 1;
+            let terminated = false;
+            while(j < length){
+                const sch = content[j];
+                if ('\\' === sch) {
+                    j += 2;
+                    continue;
+                }
+                if (sch === ch) {
+                    terminated = true;
+                    j++;
+                    break;
+                }
+                if ('\n' === sch) break;
+                j++;
+            }
+            if (terminated && isSpecifierContext(prev1, prev2, prev3)) specifiers.push({
+                start: start + 1,
+                end: j - 1,
+                value: content.slice(start + 1, j - 1)
+            });
+            pushToken('"string"');
+            i = j;
+            continue;
+        }
+        if (IDENTIFIER_CHAR.test(ch)) {
+            let j = i + 1;
+            while(j < length && IDENTIFIER_CHAR.test(content[j]))j++;
+            pushToken(content.slice(i, j));
+            i = j;
+            continue;
+        }
+        pushToken(ch);
+        i++;
+    }
+    return specifiers;
+};
+const rewriteImportSpecifiers = (content, rewrite)=>{
+    const specifiers = scanSpecifiers(content);
+    if (0 === specifiers.length) return {
+        content,
+        changed: false
+    };
+    let result = '';
+    let cursor = 0;
+    let changed = false;
+    for (const specifier of specifiers){
+        if (specifier.value.includes('\\')) continue;
+        const next = rewrite(specifier.value);
+        if (void 0 !== next && next !== specifier.value) {
+            changed = true;
+            result += content.slice(cursor, specifier.start) + next;
+            cursor = specifier.end;
+        }
+    }
+    if (!changed) return {
+        content,
+        changed: false
+    };
+    return {
+        content: result + content.slice(cursor),
+        changed: true
+    };
+};
+export { rewriteImportSpecifiers };

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

@@ -1,8 +1,8 @@
 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;
 const copyFiles = async (from, to, appDirectory)=>{
     if (await fs.pathExists(from)) {
         const relativePath = path.relative(appDirectory, from);
@@ -15,42 +15,55 @@ 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 && [
+        'preserve',
+        'esnext',
+        'es2015',
+        'es2020',
+        'es2022',
+        'es6'
+    ].includes(String(config.compilerOptions.module).toLowerCase())) {
+        config.compilerOptions.module = 'commonjs';
+        delete config.compilerOptions.moduleResolution;
+    }
+    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,
@@ -79,14 +92,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,
+    __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);
@@ -96,14 +146,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)=>{
@@ -129,24 +173,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/esm-node/compilers/typescript/importRewriter.mjs

@@ -0,0 +1,205 @@
+import "node:module";
+const IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;
+const WHITESPACE = /\s/;
+const KEYWORDS_BEFORE_REGEX = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await'
+]);
+const PUNCTUATORS_BEFORE_REGEX = new Set('{}(,;[=:?!&|+-*%^~<>/');
+const isRegexAllowed = (lastToken)=>{
+    if (!lastToken) return true;
+    if (KEYWORDS_BEFORE_REGEX.has(lastToken)) return true;
+    return 1 === lastToken.length && PUNCTUATORS_BEFORE_REGEX.has(lastToken);
+};
+const isSpecifierContext = (prev1, prev2, prev3)=>{
+    if (('from' === prev1 || 'import' === prev1) && '.' !== prev2) return true;
+    return '(' === prev1 && ('import' === prev2 || 'require' === prev2) && '.' !== prev3;
+};
+const skipRegexLiteral = (content, start)=>{
+    let i = start + 1;
+    let inClass = false;
+    while(i < content.length){
+        const ch = content[i];
+        if ('\\' === ch) {
+            i += 2;
+            continue;
+        }
+        if ('\n' === ch) break;
+        if ('[' === ch) inClass = true;
+        else if (']' === ch) inClass = false;
+        else if ('/' === ch && !inClass) {
+            i++;
+            while(i < content.length && IDENTIFIER_CHAR.test(content[i]))i++;
+            break;
+        }
+        i++;
+    }
+    return i;
+};
+const scanSpecifiers = (content)=>{
+    const specifiers = [];
+    const length = content.length;
+    const templateExpressionDepths = [];
+    let prev1 = '';
+    let prev2 = '';
+    let prev3 = '';
+    const pushToken = (token)=>{
+        prev3 = prev2;
+        prev2 = prev1;
+        prev1 = token;
+    };
+    let mode = 'code';
+    let i = 0;
+    while(i < length){
+        const ch = content[i];
+        if ('template' === mode) {
+            if ('\\' === ch) {
+                i += 2;
+                continue;
+            }
+            if ('`' === ch) {
+                mode = 'code';
+                pushToken('`');
+                i++;
+                continue;
+            }
+            if ('$' === ch && '{' === content[i + 1]) {
+                templateExpressionDepths.push(0);
+                mode = 'code';
+                pushToken('{');
+                i += 2;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (WHITESPACE.test(ch)) {
+            i++;
+            continue;
+        }
+        if ('/' === ch) {
+            const next = content[i + 1];
+            if ('/' === next) {
+                const newline = content.indexOf('\n', i + 2);
+                i = -1 === newline ? length : newline + 1;
+                continue;
+            }
+            if ('*' === next) {
+                const end = content.indexOf('*/', i + 2);
+                i = -1 === end ? length : end + 2;
+                continue;
+            }
+            if (isRegexAllowed(prev1)) {
+                i = skipRegexLiteral(content, i);
+                pushToken('/regex/');
+                continue;
+            }
+            pushToken('/');
+            i++;
+            continue;
+        }
+        if ('`' === ch) {
+            mode = 'template';
+            i++;
+            continue;
+        }
+        if ('{' === ch) {
+            if (templateExpressionDepths.length > 0) templateExpressionDepths[templateExpressionDepths.length - 1]++;
+            pushToken('{');
+            i++;
+            continue;
+        }
+        if ('}' === ch) {
+            if (templateExpressionDepths.length > 0) {
+                const top = templateExpressionDepths.length - 1;
+                if (0 === templateExpressionDepths[top]) {
+                    templateExpressionDepths.pop();
+                    mode = 'template';
+                    i++;
+                    continue;
+                }
+                templateExpressionDepths[top]--;
+            }
+            pushToken('}');
+            i++;
+            continue;
+        }
+        if ('"' === ch || "'" === ch) {
+            const start = i;
+            let j = i + 1;
+            let terminated = false;
+            while(j < length){
+                const sch = content[j];
+                if ('\\' === sch) {
+                    j += 2;
+                    continue;
+                }
+                if (sch === ch) {
+                    terminated = true;
+                    j++;
+                    break;
+                }
+                if ('\n' === sch) break;
+                j++;
+            }
+            if (terminated && isSpecifierContext(prev1, prev2, prev3)) specifiers.push({
+                start: start + 1,
+                end: j - 1,
+                value: content.slice(start + 1, j - 1)
+            });
+            pushToken('"string"');
+            i = j;
+            continue;
+        }
+        if (IDENTIFIER_CHAR.test(ch)) {
+            let j = i + 1;
+            while(j < length && IDENTIFIER_CHAR.test(content[j]))j++;
+            pushToken(content.slice(i, j));
+            i = j;
+            continue;
+        }
+        pushToken(ch);
+        i++;
+    }
+    return specifiers;
+};
+const rewriteImportSpecifiers = (content, rewrite)=>{
+    const specifiers = scanSpecifiers(content);
+    if (0 === specifiers.length) return {
+        content,
+        changed: false
+    };
+    let result = '';
+    let cursor = 0;
+    let changed = false;
+    for (const specifier of specifiers){
+        if (specifier.value.includes('\\')) continue;
+        const next = rewrite(specifier.value);
+        if (void 0 !== next && next !== specifier.value) {
+            changed = true;
+            result += content.slice(cursor, specifier.start) + next;
+            cursor = specifier.end;
+        }
+    }
+    if (!changed) return {
+        content,
+        changed: false
+    };
+    return {
+        content: result + content.slice(cursor),
+        changed: true
+    };
+};
+export { rewriteImportSpecifiers };