@bleedingdev/modern-js-server-utils 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

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

@@ -27,206 +27,115 @@ var __webpack_require__ = {};
 })();
 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);
+__webpack_require__.d(__webpack_exports__, {
+    assertNoNativeModuleOutputCollision: ()=>assertNoNativeModuleOutputCollision,
+    rewriteImportSpecifiers: ()=>rewriteImportSpecifiers
+});
+const core_namespaceObject = require("@swc/core");
+const assertNoNativeModuleOutputCollision = (sourceFile, fileExists)=>{
+    const rawModuleFile = sourceFile.endsWith('.mts') ? `${sourceFile.slice(0, -4)}.mjs` : sourceFile.endsWith('.cts') ? `${sourceFile.slice(0, -4)}.cjs` : void 0;
+    if (rawModuleFile && fileExists(rawModuleFile)) throw new Error(`Native module sources collide: "${sourceFile}" and "${rawModuleFile}" publish the same output.`);
 };
-const isSpecifierContext = (prev1, prev2, prev3)=>{
-    if (('from' === prev1 || 'import' === prev1) && '.' !== prev2) return true;
-    return '(' === prev1 && ('import' === prev2 || 'require' === prev2) && '.' !== prev3;
+const isObjectRecord = (value)=>'object' == typeof value && null !== value;
+const isAstNode = (value)=>isObjectRecord(value) && 'string' == typeof value.type;
+const isStringLiteral = (value)=>isAstNode(value) && 'StringLiteral' === value.type && 'string' == typeof value.value && 'object' == typeof value.span && null !== value.span && 'number' == typeof value.span.start && 'number' == typeof value.span.end;
+const getCallSpecifier = (node)=>{
+    if ('CallExpression' !== node.type || !Array.isArray(node.arguments)) return;
+    const callee = node.callee;
+    const isDynamicImport = isAstNode(callee) && 'Import' === callee.type;
+    const isCommonJsRequire = isAstNode(callee) && 'Identifier' === callee.type && 'require' === callee.value;
+    if (!isDynamicImport && !isCommonJsRequire) return;
+    const firstArgument = node.arguments[0];
+    if (!isObjectRecord(firstArgument)) return;
+    return isStringLiteral(firstArgument.expression) ? firstArgument.expression : void 0;
 };
-const isCallSpecifierContext = (prev1, prev2, prev3)=>'(' === prev1 && ('import' === prev2 || 'require' === prev2) && '.' !== prev3;
-const nextNonTriviaChar = (content, start)=>{
-    let i = start;
-    while(i < content.length){
-        if (WHITESPACE.test(content[i])) {
-            i++;
-            continue;
-        }
-        if ('/' === content[i] && '/' === content[i + 1]) {
-            const newline = content.indexOf('\n', i + 2);
-            i = -1 === newline ? content.length : newline + 1;
-            continue;
-        }
-        if ('/' === content[i] && '*' === content[i + 1]) {
-            const end = content.indexOf('*/', i + 2);
-            i = -1 === end ? content.length : end + 2;
-            continue;
+const collectSpecifierLiterals = (content)=>{
+    const parserOptions = {
+        decorators: true,
+        syntax: "typescript",
+        target: 'esnext'
+    };
+    let program;
+    try {
+        program = (0, core_namespaceObject.parseSync)(content, parserOptions);
+    } catch (typescriptError) {
+        try {
+            program = (0, core_namespaceObject.parseSync)(content, {
+                ...parserOptions,
+                tsx: true
+            });
+        } catch  {
+            throw typescriptError;
         }
-        return content[i];
     }
-    return '';
-};
-const skipRegexLiteral = (content, start)=>{
-    let i = start + 1;
-    let inClass = false;
-    while(i < content.length){
-        const ch = content[i];
-        if ('\\' === ch) {
-            i += 2;
-            continue;
+    const literals = [];
+    const seenSpans = new Set();
+    const add = (value)=>{
+        if (!isStringLiteral(value)) return;
+        const spanKey = `${value.span.start}:${value.span.end}`;
+        if (!seenSpans.has(spanKey)) {
+            seenSpans.add(spanKey);
+            literals.push(value);
         }
-        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;
+    };
+    const visit = (value)=>{
+        if (Array.isArray(value)) return void value.forEach(visit);
+        if (!isObjectRecord(value)) return;
+        if (isAstNode(value)) switch(value.type){
+            case 'ImportDeclaration':
+            case 'ExportAllDeclaration':
+            case 'ExportNamedDeclaration':
+                add(value.source);
+                break;
+            case 'TsImportType':
+                add(value.argument);
+                break;
+            case 'TsExternalModuleReference':
+                add(value.expression);
+                break;
+            case 'CallExpression':
+                add(getCallSpecifier(value));
+                break;
         }
-        i++;
+        for (const [key, child] of Object.entries(value))if ('span' !== key) visit(child);
+    };
+    visit(program);
+    return literals.sort((left, right)=>left.span.start - right.span.start);
+};
+const mapUtf8ByteOffsets = (content, byteOffsets)=>{
+    const pending = new Set(byteOffsets);
+    const result = new Map();
+    let byteOffset = 0;
+    let stringOffset = 0;
+    while(stringOffset <= content.length && pending.size > 0){
+        if (pending.delete(byteOffset)) result.set(byteOffset, stringOffset);
+        if (stringOffset === content.length) break;
+        const codePoint = content.codePointAt(stringOffset);
+        if (void 0 === codePoint) break;
+        const character = String.fromCodePoint(codePoint);
+        byteOffset += Buffer.byteLength(character);
+        stringOffset += character.length;
     }
-    return i;
+    if (pending.size > 0) throw new Error('SWC returned an import specifier span outside its source');
+    return result;
 };
 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++;
-            }
-            const callSpecifier = isCallSpecifierContext(prev1, prev2, prev3);
-            const nextChar = callSpecifier ? nextNonTriviaChar(content, j) : '';
-            const isCompleteCallSpecifier = !callSpecifier || ')' === nextChar || ',' === nextChar;
-            if (terminated && isSpecifierContext(prev1, prev2, prev3) && isCompleteCallSpecifier) 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 literals = collectSpecifierLiterals(content);
+    const byteOffsets = literals.flatMap((literal)=>[
+            literal.span.start,
+            literal.span.end - 2
+        ]);
+    const stringOffsets = mapUtf8ByteOffsets(content, byteOffsets);
+    return literals.map((literal)=>{
+        const start = stringOffsets.get(literal.span.start);
+        const end = stringOffsets.get(literal.span.end - 2);
+        if (void 0 === start || void 0 === end) throw new Error('Could not locate an SWC import specifier in its source');
+        return {
+            start,
+            end,
+            value: content.slice(start, end)
+        };
+    });
 };
 const rewriteImportSpecifiers = (content, rewrite)=>{
     const specifiers = scanSpecifiers(content);
@@ -255,11 +164,10 @@ const rewriteImportSpecifiers = (content, rewrite)=>{
         changed: true
     };
 };
-__webpack_require__.d(__webpack_exports__, {}, {
-    rewriteImportSpecifiers: rewriteImportSpecifiers
-});
+exports.assertNoNativeModuleOutputCollision = __webpack_exports__.assertNoNativeModuleOutputCollision;
 exports.rewriteImportSpecifiers = __webpack_exports__.rewriteImportSpecifiers;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertNoNativeModuleOutputCollision",
     "rewriteImportSpecifiers"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -53,12 +53,7 @@ const copyFiles = async (from, to, appDirectory)=>{
         const relativePath = external_path_default().relative(appDirectory, from);
         const targetDir = external_path_default().join(to, relativePath);
         await utils_namespaceObject.fs.copy(from, targetDir, {
-            filter: (src)=>![
-                    '.ts',
-                    '.tsx',
-                    '.js',
-                    '.jsx'
-                ].includes(external_path_default().extname(src)) && !src.endsWith('tsconfig.json')
+            filter: (src)=>!/\.(?:[cm]?ts|tsx|jsx?)$/u.test(src) && !src.endsWith('tsconfig.json')
         });
     }
 };
@@ -155,7 +150,7 @@ const runTsgo = (tsgoBinPath, args, options)=>new Promise((resolve, reject)=>{
     });
 const getTsgoBinEntry = (pkg)=>{
     if ('string' == typeof pkg.bin) return pkg.bin;
-    return pkg.bin?.tsgo;
+    return pkg.bin?.tsc ?? pkg.bin?.tsgo;
 };
 const resolveTsgoBinPath = (pkgPath)=>{
     const pkgDir = external_path_default().dirname(pkgPath);
@@ -172,12 +167,19 @@ const getTsgoBinPath = (appDirectory, resolvePaths = [
     __dirname
 ])=>{
     try {
-        const pkgPath = require.resolve("@typescript/native-preview/package.json", {
-            paths: resolvePaths
-        });
+        let pkgPath;
+        try {
+            pkgPath = require.resolve("@typescript/native/package.json", {
+                paths: resolvePaths
+            });
+        } catch  {
+            pkgPath = require.resolve("@typescript/native-preview/package.json", {
+                paths: resolvePaths
+            });
+        }
         return resolveTsgoBinPath(pkgPath);
     } catch  {
-        throw new Error('tsgo could not be found! Please install "@typescript/native-preview" in your project to compile BFF/server code.');
+        throw new Error('tsgo could not be found! Please install "@typescript/native" (or legacy "@typescript/native-preview") in your project to compile BFF/server code.');
     }
 };
 const OUTPUT_SOURCE_EXTENSIONS = {
@@ -237,6 +239,7 @@ const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, mo
     await Promise.all(files.map(async (file)=>{
         const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
         if (!sourceFile) return;
+        (0, external_importRewriter_js_namespaceObject.assertNoNativeModuleOutputCollision)(sourceFile, utils_namespaceObject.fs.existsSync);
         const content = await utils_namespaceObject.fs.readFile(file, 'utf8');
         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));
@@ -293,6 +296,7 @@ const compileByTs = async (appDirectory, config, compileOptions)=>{
         } else process.exit(1);
     }
     for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
+    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
     utils_namespaceObject.logger.info("TS-Go compile succeed");
 };
 exports.compileByTs = __webpack_exports__.compileByTs;

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

@@ -52,18 +52,47 @@ const toImportSpecifier = (sourceFile, resolvedPath)=>{
     const relativePath = pathApi.relative(pathApi.dirname(sourceFile), resolvedPath).split(pathApi.sep).join(external_path_default().posix.sep);
     return '.' === relativePath[0] ? relativePath : `./${relativePath}`;
 };
-const COMPILED_TO_JS_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx'
+const SOURCE_TO_OUTPUT_EXTENSION = new Map([
+    [
+        '.ts',
+        '.js'
+    ],
+    [
+        '.tsx',
+        '.js'
+    ],
+    [
+        '.js',
+        '.js'
+    ],
+    [
+        '.jsx',
+        '.js'
+    ],
+    [
+        '.mts',
+        '.mjs'
+    ],
+    [
+        '.mjs',
+        '.mjs'
+    ],
+    [
+        '.cts',
+        '.cjs'
+    ],
+    [
+        '.cjs',
+        '.cjs'
+    ]
 ]);
 const toEsmOutputPath = (resolvedPath)=>{
     const sourcePath = ((0, utils_namespaceObject.findSourceEntry)(resolvedPath) || resolvedPath).replace(/\\/g, '/');
     const ext = external_path_default().extname(sourcePath);
     if (!ext) return `${sourcePath}.js`;
-    if (!COMPILED_TO_JS_EXTENSIONS.has(ext)) return sourcePath;
-    return `${sourcePath.slice(0, -ext.length)}.js`;
+    const outputExtension = SOURCE_TO_OUTPUT_EXTENSION.get(ext);
+    if (!outputExtension) return sourcePath;
+    return `${sourcePath.slice(0, -ext.length)}${outputExtension}`;
 };
 const resolveRelativeEsmSpecifier = (sourceFile, text)=>{
     if (!text.startsWith('./') && !text.startsWith('../')) return;
@@ -151,7 +180,7 @@ function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
             if (packagePath) return text;
         } catch  {}
     }
-    if ('module' === moduleType) result = toEsmOutputPath(result);
+    if ('module' === moduleType || /\.[cm]ts$/iu.test(result)) result = toEsmOutputPath(result);
     return toImportSpecifier(sourceFile, result) || './';
 }
 exports.createTsconfigPathsMatcher = __webpack_exports__.createTsconfigPathsMatcher;