@bleedingdev/modern-js-server-utils 3.9.0-ultramodern.18 → 3.9.0-ultramodern.19

package/dist/esm-node/compilers/tsgo.mjs

@@ -0,0 +1,140 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fs } from "@modern-js/utils";
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+let resolvedConfigCount = 0;
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles = [])=>{
+    const tsconfigDir = path.dirname(tsconfigPath);
+    const output = await runTsgo(tsgoBinPath, [
+        '--showConfig',
+        '-p',
+        tsconfigPath
+    ], {
+        cwd: tsconfigDir
+    });
+    const config = JSON.parse(output.stdout);
+    config.compilerOptions ??= {};
+    const options = config.compilerOptions;
+    options.rootDir = appDirectory;
+    options.composite = false;
+    options.declarationMap = false;
+    options.incremental = false;
+    options.noEmit = true !== options.declaration;
+    options.jsx ??= 'react-jsx';
+    delete options.emitDeclarationOnly;
+    delete options.outDir;
+    delete options.tsBuildInfoFile;
+    config.files = filterSourceFiles(tsconfigDir, sourceDirs, config.files, excludeFiles);
+    delete config.include;
+    delete config.references;
+    if (void 0 !== options.baseUrl) {
+        const baseUrl = path.resolve(tsconfigDir, options.baseUrl);
+        if (options.paths) options.paths = Object.fromEntries(Object.entries(options.paths).map(([key, targets])=>[
+                key,
+                targets.map((target)=>{
+                    const relative = path.relative(tsconfigDir, path.resolve(baseUrl, target)).split(path.sep).join(path.posix.sep);
+                    return relative.startsWith('.') ? relative : `./${relative}`;
+                })
+            ]));
+        delete options.baseUrl;
+    }
+    if ([
+        'node',
+        'node10'
+    ].includes(String(options.moduleResolution).toLowerCase())) delete options.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 toPosix = (file)=>file.split(path.sep).join(path.posix.sep);
+const filterSourceFiles = (tsconfigDir, sourceDirs, files = [], excludeFiles = [])=>{
+    const sourcePosixPaths = sourceDirs.map(toPosix);
+    const excludedPaths = new Set(excludeFiles.map((file)=>toPosix(path.normalize(file))));
+    return files.filter((fileName)=>{
+        const absoluteFileName = toPosix(path.resolve(tsconfigDir, fileName));
+        if (excludedPaths.has(absoluteFileName)) return false;
+        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
+    });
+};
+const runTsgo = (tsgoBinPath, args, options)=>new Promise((resolve, reject)=>{
+        const child = spawn(process.execPath, [
+            tsgoBinPath,
+            ...args
+        ], {
+            cwd: options.cwd,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data)=>{
+            stdout += data;
+        });
+        child.stderr.on('data', (data)=>{
+            stderr += data;
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            const result = {
+                stdout,
+                stderr,
+                code: code ?? 1
+            };
+            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
+            resolve(result);
+        });
+    });
+const getTsgoBinEntry = (pkg)=>{
+    if ('string' == typeof pkg.bin) return pkg.bin;
+    return pkg.bin?.tsc ?? pkg.bin?.tsgo;
+};
+const TSGO_PACKAGES = [
+    "@typescript/native",
+    "@typescript/native-preview"
+];
+const resolveTsgoPackage = (resolvePaths)=>{
+    for (const name of TSGO_PACKAGES)try {
+        const pkgPath = require.resolve(`${name}/package.json`, {
+            paths: resolvePaths
+        });
+        return {
+            name,
+            pkgPath
+        };
+    } catch  {}
+    throw new Error('tsgo could not be found! Please install "@typescript/native" (or legacy "@typescript/native-preview") in your project to type-check BFF/server code.');
+};
+const getTsgoBinPath = (appDirectory, resolvePaths = [
+    appDirectory,
+    __rspack_import_meta_dirname__
+])=>{
+    const { pkgPath } = resolveTsgoPackage(resolvePaths);
+    const pkgDir = path.dirname(pkgPath);
+    const pkg = require(pkgPath);
+    const declaredBinEntry = getTsgoBinEntry(pkg);
+    const candidates = [
+        declaredBinEntry ? path.resolve(pkgDir, declaredBinEntry) : void 0,
+        path.join(pkgDir, 'bin/tsgo.js')
+    ].filter((candidate)=>Boolean(candidate));
+    return candidates.find((candidate)=>fs.existsSync(candidate)) ?? candidates[0];
+};
+const getTsgoModulePath = (appDirectory, resolvePaths = [
+    appDirectory,
+    __rspack_import_meta_dirname__
+])=>{
+    const { name } = resolveTsgoPackage(resolvePaths);
+    return require.resolve(name, {
+        paths: resolvePaths
+    });
+};
+export { createResolvedTsgoConfig, getTsgoBinPath, getTsgoModulePath, runTsgo };

package/dist/types/common/index.d.ts

@@ -6,9 +6,6 @@ export interface Pattern {
 }
 export interface IConfig {
     alias?: SourceNormalizedConfig['alias'];
-    server?: {
-        compiler?: 'typescript';
-    };
 }
 export interface CompileOptions {
     sourceDirs: string[];

package/dist/types/compilers/rslib.d.ts

@@ -0,0 +1,10 @@
+import type { CompileOptions, IConfig } from '../common/index.js';
+/**
+ * Compile server sources file-by-file with Rslib (bundleless, Node target).
+ * Rspack resolves `source.alias` and tsconfig `paths` while it emits, so the
+ * output specifiers and source maps are right the first time. TS-Go only
+ * type-checks, and emits declarations when the app's tsconfig asks for them.
+ */
+export declare const compileServerSources: (appDirectory: string, config: IConfig, options: CompileOptions & {
+    tsconfigPath: string;
+}) => Promise<void>;

package/dist/types/compilers/tsgo.d.ts

@@ -0,0 +1,49 @@
+type TsgoConfig = {
+    compilerOptions?: {
+        allowJs?: boolean;
+        baseUrl?: string;
+        composite?: boolean;
+        declaration?: boolean;
+        declarationMap?: boolean;
+        emitDeclarationOnly?: boolean;
+        experimentalDecorators?: boolean;
+        incremental?: boolean;
+        jsx?: string;
+        moduleResolution?: string;
+        noEmit?: boolean;
+        noEmitOnError?: boolean;
+        outDir?: string;
+        paths?: Record<string, string[]>;
+        rootDir?: string;
+        tsBuildInfoFile?: string;
+    };
+    files?: string[];
+    include?: string[];
+    references?: Array<{
+        path: string;
+    }>;
+};
+/**
+ * Write a one-shot tsconfig for type-checking (and, when the app asks for
+ * declarations, declaration emit) of exactly the server source directories.
+ * JavaScript is emitted by Rslib, so nothing here shapes runtime output.
+ */
+export declare const createResolvedTsgoConfig: (appDirectory: string, tsconfigPath: string, sourceDirs: string[], tsgoBinPath: string, excludeFiles?: string[]) => Promise<{
+    config: TsgoConfig;
+    resolvedConfigPath: string;
+}>;
+export declare const runTsgo: (tsgoBinPath: string, args: string[], options: {
+    cwd: string;
+    reject?: boolean;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+}>;
+export declare const getTsgoBinPath: (appDirectory: string, resolvePaths?: string[]) => string;
+/**
+ * The TS-Go package entry that Rslib's declaration emitter loads to read the
+ * compiler version and locate its executable.
+ */
+export declare const getTsgoModulePath: (appDirectory: string, resolvePaths?: string[]) => string;
+export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.18",
+  "version": "3.9.0-ultramodern.19",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -38,13 +38,12 @@
     }
   },
   "dependencies": {
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.18",
-    "@swc/core": "1.16.2",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.19",
+    "@rslib/core": "1.0.2",
     "@swc/helpers": "^0.5.23"
   },
   "devDependencies": {
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.18",
-    "@rslib/core": "1.0.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.19",
     "@scripts/rstest-config": "2.66.0",
     "@types/node": "^26.6.2",
     "@typescript/native-preview": "7.0.0-dev.20260707.2"

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

@@ -1,175 +0,0 @@
-"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__);
-__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 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 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;
-        }
-    }
-    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);
-        }
-    };
-    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;
-        }
-        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;
-    }
-    if (pending.size > 0) throw new Error('SWC returned an import specifier span outside its source');
-    return result;
-};
-const scanSpecifiers = (content)=>{
-    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);
-    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
-    };
-};
-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', {
-    value: true
-});