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

package/dist/cjs/common/index.js

@@ -1,11 +1,15 @@
 "use strict";
 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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

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

@@ -0,0 +1,242 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+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
+    };
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    rewriteImportSpecifiers: rewriteImportSpecifiers
+});
+exports.rewriteImportSpecifiers = __webpack_exports__.rewriteImportSpecifiers;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rewriteImportSpecifiers"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -10,11 +10,15 @@ 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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -33,14 +37,17 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    compileByTs: ()=>compileByTs
+    compileByTs: ()=>compileByTs,
+    createResolvedTsgoConfig: ()=>createResolvedTsgoConfig,
+    getTsgoBinPath: ()=>getTsgoBinPath,
+    rewriteOutputSpecifiers: ()=>rewriteOutputSpecifiers
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const external_child_process_namespaceObject = require("child_process");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_importRewriter_js_namespaceObject = require("./importRewriter.js");
 const external_tsconfigPathsPlugin_js_namespaceObject = require("./tsconfigPathsPlugin.js");
-const importSpecifierRE = /((?:from\s*|import\s*\(\s*|require\s*\(\s*)['"])([^'"]+)(['"])/g;
 const copyFiles = async (from, to, appDirectory)=>{
     if (await utils_namespaceObject.fs.pathExists(from)) {
         const relativePath = external_path_default().relative(appDirectory, from);
@@ -53,42 +60,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 = external_path_default().dirname(tsconfigPath);
+    const output = await runTsgo(tsgoBinPath, [
         '--showConfig',
         '-p',
         tsconfigPath
     ], {
-        cwd: external_path_default().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 = external_path_default().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 = external_path_default().join(tsconfigDir, `.tsgo.${process.pid}.${resolvedConfigCount++}.resolved.json`);
     await utils_namespaceObject.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(external_path_default().sep).join(external_path_default().posix.sep));
     return files.filter((fileName)=>{
-        const absoluteFileName = external_path_default().resolve(appDirectory, fileName).split(external_path_default().sep).join(external_path_default().posix.sep);
+        const absoluteFileName = external_path_default().resolve(tsconfigDir, fileName).split(external_path_default().sep).join(external_path_default().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 = (0, external_child_process_namespaceObject.spawn)(process.execPath, [
-            getTsgoBinPath(),
+            tsgoBinPath,
             ...args
         ], {
             cwd: options.cwd,
@@ -117,14 +137,51 @@ const runTsgo = (args, options)=>new Promise((resolve, reject)=>{
             resolve(result);
         });
     });
-const getTsgoBinPath = ()=>external_path_default().join(external_path_default().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 external_path_default().join(external_path_default().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 = external_path_default().relative(distDir, outputFile);
     const parsed = external_path_default().parse(relativeOutput);
     const sourceBase = external_path_default().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 (utils_namespaceObject.fs.existsSync(candidate)) return candidate;
+    }
+};
+const sourceMappingUrlRE = /^\/\/[#@] sourceMappingURL=.*$/gm;
+const dropStaleSourceMap = async (outputFile, content)=>{
+    const mapFile = `${outputFile}.map`;
+    if (await utils_namespaceObject.fs.pathExists(mapFile)) await utils_namespaceObject.fs.remove(mapFile);
+    return content.replace(sourceMappingUrlRE, '');
 };
-const findExistingSource = (filePath)=>utils_namespaceObject.fs.existsSync(filePath) ? filePath : void 0;
 const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
     if (0 === Object.keys(paths).length || !await utils_namespaceObject.fs.pathExists(distDir)) return;
     const matcher = (0, external_tsconfigPathsPlugin_js_namespaceObject.createTsconfigPathsMatcher)(baseUrl, paths);
@@ -134,14 +191,8 @@ const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, mo
         const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
         if (!sourceFile) return;
         const content = await utils_namespaceObject.fs.readFile(file, 'utf8');
-        let changed = false;
-        const rewritten = content.replace(importSpecifierRE, (match, prefix, specifier, suffix)=>{
-            const nextSpecifier = (0, external_tsconfigPathsPlugin_js_namespaceObject.getNotAliasedPath)(sourceFile, matcher, specifier, moduleType);
-            if (!nextSpecifier || nextSpecifier === specifier) return match;
-            changed = true;
-            return `${prefix}${nextSpecifier}${suffix}`;
-        });
-        if (changed) await utils_namespaceObject.fs.writeFile(file, rewritten);
+        const { content: rewritten, changed } = (0, external_importRewriter_js_namespaceObject.rewriteImportSpecifiers)(content, (specifier)=>(0, external_tsconfigPathsPlugin_js_namespaceObject.getNotAliasedPath)(sourceFile, matcher, specifier, moduleType));
+        if (changed) await utils_namespaceObject.fs.writeFile(file, await dropStaleSourceMap(file, rewritten));
     }));
 };
 const collectOutputFiles = async (dir)=>{
@@ -167,29 +218,45 @@ 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 utils_namespaceObject.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 utils_namespaceObject.fs.remove(resolvedConfigPath);
+    }
     if (result.stderr) utils_namespaceObject.logger.error(result.stderr);
     if (result.stdout) utils_namespaceObject.logger.info(result.stdout);
     if (0 !== result.code) {
         const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
-        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) utils_namespaceObject.logger.error('TS-Go compilation failed');
-        else process.exit(1);
+        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) {
+            utils_namespaceObject.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);
     utils_namespaceObject.logger.info("TS-Go compile succeed");
 };
 exports.compileByTs = __webpack_exports__.compileByTs;
+exports.createResolvedTsgoConfig = __webpack_exports__.createResolvedTsgoConfig;
+exports.getTsgoBinPath = __webpack_exports__.getTsgoBinPath;
+exports.rewriteOutputSpecifiers = __webpack_exports__.rewriteOutputSpecifiers;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "compileByTs"
+    "compileByTs",
+    "createResolvedTsgoConfig",
+    "getTsgoBinPath",
+    "rewriteOutputSpecifiers"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -10,11 +10,15 @@ 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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/cjs/index.js

@@ -1,11 +1,15 @@
 "use strict";
 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__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{