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

package/dist/cjs/common/index.js

@@ -31,6 +31,7 @@ __webpack_require__.d(__webpack_exports__, {
     FILE_EXTENSIONS: ()=>FILE_EXTENSIONS,
     compile: ()=>compile
 });
+const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 const FILE_EXTENSIONS = [
     '.js',
@@ -49,8 +50,18 @@ const compile = async (appDirectory, modernConfig, compileOptions)=>{
     validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
     validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
     validateAbsolutePaths(excludeFiles, (file)=>`excluded file ${file} is not an absolute path.`);
-    const { compileByTs } = await import("../compilers/typescript/index.js");
-    await compileByTs(appDirectory, modernConfig, compileOptions);
+    if (!tsconfigPath) return;
+    const { compileServerSources } = await import("../compilers/rslib.js");
+    try {
+        await compileServerSources(appDirectory, modernConfig, {
+            ...compileOptions,
+            tsconfigPath
+        });
+    } catch (error) {
+        if (compileOptions.throwErrorInsteadOfExit) throw error;
+        utils_namespaceObject.logger.error(error);
+        process.exit(1);
+    }
 };
 exports.FILE_EXTENSIONS = __webpack_exports__.FILE_EXTENSIONS;
 exports.compile = __webpack_exports__.compile;

package/dist/cjs/compilers/rslib.js

@@ -0,0 +1,305 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    compileServerSources: ()=>compileServerSources
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_tsgo_js_namespaceObject = require("./tsgo.js");
+const SCRIPT_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/u;
+const DECLARATION_RE = /\.d\.[cm]?ts$/u;
+const TS_RE = /\.[cm]?tsx?$/u;
+const toPosix = (file)=>file.split(external_path_default().sep).join(external_path_default().posix.sep);
+const escapeGlob = (file)=>file.replace(/[()[\]{}*?!+@]/gu, '\\$&');
+const walk = async (dir)=>{
+    if (!await utils_namespaceObject.fs.pathExists(dir)) return [];
+    const entries = await utils_namespaceObject.fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map((entry)=>{
+        const file = external_path_default().join(dir, entry.name);
+        if (entry.isDirectory()) return 'node_modules' === entry.name ? [] : walk(file);
+        return [
+            file
+        ];
+    }));
+    return files.flat();
+};
+const outputExtension = (file)=>/\.m[jt]s$/u.test(file) ? '.mjs' : /\.c[jt]s$/u.test(file) ? '.cjs' : '.js';
+const collectSources = async (sourceDirs, excludeFiles)=>{
+    const excluded = new Set(excludeFiles.map((file)=>external_path_default().normalize(file)));
+    return (await Promise.all(sourceDirs.map(walk))).flat().filter((file)=>SCRIPT_RE.test(file) && !DECLARATION_RE.test(file) && !excluded.has(external_path_default().normalize(file)));
+};
+const groupEntries = (appDirectory, files)=>{
+    const outputs = new Map();
+    const entries = {
+        '.js': [],
+        '.mjs': [],
+        '.cjs': []
+    };
+    for (const file of files){
+        const extension = outputExtension(file);
+        const output = `${file.replace(SCRIPT_RE, '')}${extension}`;
+        const existing = outputs.get(output);
+        if (existing) throw new Error(`"${existing}" and "${file}" both compile to "${toPosix(external_path_default().relative(appDirectory, output))}". Rename one of them.`);
+        outputs.set(output, file);
+        entries[extension].push(escapeGlob(toPosix(external_path_default().relative(appDirectory, file))));
+    }
+    return entries;
+};
+const resolveAlias = (appDirectory, alias)=>Object.fromEntries(Object.entries((0, utils_namespaceObject.mergeAlias)(alias)).map(([key, target])=>[
+            key,
+            [].concat(target).map((value)=>value.startsWith('.') ? external_path_default().resolve(appDirectory, value) : value)
+        ]));
+const copyAssets = async (sourceDir, appDirectory, distDir)=>{
+    if (!await utils_namespaceObject.fs.pathExists(sourceDir)) return;
+    await utils_namespaceObject.fs.copy(sourceDir, external_path_default().join(distDir, external_path_default().relative(appDirectory, sourceDir)), {
+        filter: (src)=>!SCRIPT_RE.test(src) && !src.endsWith('tsconfig.json')
+    });
+};
+const matchAlias = (alias, request)=>{
+    for (const [key, targets] of Object.entries(alias)){
+        const exact = key.endsWith('$');
+        const name = exact ? key.slice(0, -1) : key;
+        if (request === name || !exact && request.startsWith(`${name}/`)) return {
+            targets,
+            rest: request.slice(name.length)
+        };
+    }
+};
+const isBareSpecifier = (specifier)=>!/^[./]/u.test(specifier) && !external_path_default().isAbsolute(specifier);
+const relativeSpecifier = (from, to)=>{
+    const relative = toPosix(external_path_default().relative(from, to));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+};
+const importEmittedFile = ({ appDirectory, distDir, alias, sources, reached, assets })=>async ({ request, context, contextInfo, getResolve })=>{
+        if (!request || !context || !contextInfo?.issuer || !getResolve) return;
+        const resolve = getResolve();
+        const resolved = await resolve(context, request).catch(()=>'');
+        if (!resolved) return /^[./]/u.test(request) ? void 0 : request;
+        const fromApp = external_path_default().relative(appDirectory, resolved);
+        if (fromApp.startsWith('..') || external_path_default().isAbsolute(fromApp) || resolved.includes(`${external_path_default().sep}node_modules${external_path_default().sep}`)) {
+            const aliased = matchAlias(alias, request);
+            if (!aliased) return request;
+            for (const target of aliased.targets.filter(isBareSpecifier)){
+                const specifier = `${target}${aliased.rest}`;
+                if (await resolve(context, specifier).catch(()=>'') === resolved) return specifier;
+            }
+            const outputDir = external_path_default().join(distDir, external_path_default().relative(appDirectory, external_path_default().dirname(contextInfo.issuer)));
+            return relativeSpecifier(outputDir, resolved);
+        }
+        const script = SCRIPT_RE.test(resolved) && !DECLARATION_RE.test(resolved);
+        if (script && !sources.has(resolved)) reached.add(resolved);
+        if (!script) assets.add(resolved);
+        const emitted = script ? `${resolved.replace(SCRIPT_RE, '')}${outputExtension(resolved)}` : resolved;
+        return relativeSpecifier(external_path_default().dirname(contextInfo.issuer), emitted);
+    };
+const compileServerSources = async (appDirectory, config, options)=>{
+    const { sourceDirs, distDir, tsconfigPath, moduleType, excludeFiles = [] } = options;
+    const sources = new Set(await collectSources(sourceDirs, excludeFiles));
+    const copyAllAssets = async ()=>{
+        for (const sourceDir of sourceDirs)await copyAssets(sourceDir, appDirectory, distDir);
+    };
+    const tsgoBinPath = (0, external_tsgo_js_namespaceObject.getTsgoBinPath)(appDirectory);
+    const { config: tsconfig, resolvedConfigPath } = await (0, external_tsgo_js_namespaceObject.createResolvedTsgoConfig)(appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles);
+    const compilerOptions = tsconfig.compilerOptions ?? {};
+    const tsconfigDir = external_path_default().dirname(tsconfigPath);
+    const roots = new Set((tsconfig.files ?? []).map((file)=>external_path_default().resolve(tsconfigDir, file)));
+    for (const file of sources){
+        const checked = true === compilerOptions.allowJs || TS_RE.test(file);
+        if (checked && !roots.has(external_path_default().resolve(file))) sources.delete(file);
+    }
+    const failOnTypeError = false !== compilerOptions.noEmitOnError;
+    const declaration = true === compilerOptions.declaration;
+    const formats = {
+        '.js': 'module' === moduleType ? 'esm' : 'cjs',
+        '.mjs': 'esm',
+        '.cjs': 'cjs'
+    };
+    const createLibs = (entries)=>{
+        const libs = Object.keys(entries).filter((extension)=>entries[extension].length > 0).map((extension)=>({
+                format: formats[extension],
+                bundle: false,
+                autoExtension: false,
+                outBase: appDirectory,
+                source: {
+                    entry: {
+                        index: entries[extension]
+                    }
+                },
+                output: {
+                    filename: {
+                        js: `[name]${extension}`
+                    }
+                }
+            }));
+        if (declaration) {
+            libs[0].redirect = {
+                dts: {
+                    extension: 'module' === moduleType
+                }
+            };
+            libs[0].dts = {
+                bundle: false,
+                distPath: distDir,
+                tsgo: true,
+                typescriptPath: (0, external_tsgo_js_namespaceObject.getTsgoModulePath)(appDirectory),
+                abortOnError: failOnTypeError
+            };
+        }
+        return libs;
+    };
+    const alias = resolveAlias(appDirectory, config.alias);
+    const assets = new Set();
+    const build = async ()=>{
+        if (0 === sources.size) return;
+        const { createRslib } = await import("@rslib/core");
+        for(;;){
+            const reached = new Set();
+            const rslib = await createRslib({
+                cwd: appDirectory,
+                config: {
+                    lib: createLibs(groupEntries(appDirectory, sources)),
+                    source: {
+                        tsconfigPath: resolvedConfigPath,
+                        ...compilerOptions.experimentalDecorators ? {
+                            decorators: {
+                                version: 'legacy'
+                            }
+                        } : {}
+                    },
+                    resolve: {
+                        alias
+                    },
+                    output: {
+                        target: 'node',
+                        distPath: {
+                            root: distDir
+                        },
+                        cleanDistPath: false,
+                        sourceMap: {
+                            js: 'source-map'
+                        }
+                    },
+                    performance: {
+                        buildCache: false
+                    },
+                    tools: {
+                        rspack: (rspackConfig)=>{
+                            rspackConfig.externals = [
+                                importEmittedFile({
+                                    appDirectory,
+                                    distDir,
+                                    alias,
+                                    sources,
+                                    reached,
+                                    assets
+                                }),
+                                ...[
+                                    rspackConfig.externals ?? []
+                                ].flat()
+                            ];
+                        }
+                    }
+                }
+            });
+            await rslib.build();
+            if (0 === reached.size) return;
+            for (const file of reached)sources.add(file);
+        }
+    };
+    const typeCheck = async ()=>{
+        if (0 === roots.size) return;
+        const result = await (0, external_tsgo_js_namespaceObject.runTsgo)(tsgoBinPath, [
+            '-p',
+            resolvedConfigPath,
+            '--noEmit'
+        ], {
+            cwd: appDirectory,
+            reject: false
+        });
+        if (0 === result.code) return;
+        const diagnostics = result.stdout.trim() || result.stderr.trim();
+        if (!failOnTypeError) return void utils_namespaceObject.logger.warn(`TS-Go type check found errors:\n${diagnostics}`);
+        throw new Error([
+            `TS-Go type check failed with exit code ${result.code}.`,
+            diagnostics
+        ].filter(Boolean).join('\n'));
+    };
+    const checkReachedSources = async ()=>{
+        const reachedRoots = [
+            ...sources
+        ].filter((file)=>!roots.has(external_path_default().resolve(file)) && (true === compilerOptions.allowJs || TS_RE.test(file)));
+        if (0 === reachedRoots.length) return typeCheck();
+        for (const file of reachedRoots)roots.add(external_path_default().resolve(file));
+        tsconfig.files = [
+            ...tsconfig.files ?? [],
+            ...reachedRoots.map((file)=>toPosix(external_path_default().relative(tsconfigDir, file)))
+        ];
+        await utils_namespaceObject.fs.writeFile(resolvedConfigPath, JSON.stringify(tsconfig, null, 2));
+        return typeCheck();
+    };
+    let results;
+    try {
+        const built = await Promise.allSettled([
+            build()
+        ]);
+        results = [
+            ...await Promise.allSettled([
+                checkReachedSources()
+            ]),
+            ...built
+        ];
+    } finally{
+        await utils_namespaceObject.fs.remove(resolvedConfigPath);
+    }
+    const failure = results.find((result)=>'rejected' === result.status);
+    if (failure) throw failure.reason;
+    await copyAllAssets();
+    for (const asset of assets)await utils_namespaceObject.fs.copy(asset, external_path_default().join(distDir, external_path_default().relative(appDirectory, asset)));
+    utils_namespaceObject.logger.info('Server sources compiled');
+};
+exports.compileServerSources = __webpack_exports__.compileServerSources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compileServerSources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compilers/tsgo.js

@@ -0,0 +1,192 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    createResolvedTsgoConfig: ()=>createResolvedTsgoConfig,
+    getTsgoBinPath: ()=>getTsgoBinPath,
+    getTsgoModulePath: ()=>getTsgoModulePath,
+    runTsgo: ()=>runTsgo
+});
+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);
+let resolvedConfigCount = 0;
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles = [])=>{
+    const tsconfigDir = external_path_default().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 = external_path_default().resolve(tsconfigDir, options.baseUrl);
+        if (options.paths) options.paths = Object.fromEntries(Object.entries(options.paths).map(([key, targets])=>[
+                key,
+                targets.map((target)=>{
+                    const relative = external_path_default().relative(tsconfigDir, external_path_default().resolve(baseUrl, target)).split(external_path_default().sep).join(external_path_default().posix.sep);
+                    return relative.startsWith('.') ? relative : `./${relative}`;
+                })
+            ]));
+        delete options.baseUrl;
+    }
+    if ([
+        'node',
+        'node10'
+    ].includes(String(options.moduleResolution).toLowerCase())) delete options.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 toPosix = (file)=>file.split(external_path_default().sep).join(external_path_default().posix.sep);
+const filterSourceFiles = (tsconfigDir, sourceDirs, files = [], excludeFiles = [])=>{
+    const sourcePosixPaths = sourceDirs.map(toPosix);
+    const excludedPaths = new Set(excludeFiles.map((file)=>toPosix(external_path_default().normalize(file))));
+    return files.filter((fileName)=>{
+        const absoluteFileName = toPosix(external_path_default().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 = (0, external_child_process_namespaceObject.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,
+    __dirname
+])=>{
+    const { pkgPath } = resolveTsgoPackage(resolvePaths);
+    const pkgDir = external_path_default().dirname(pkgPath);
+    const pkg = require(pkgPath);
+    const declaredBinEntry = getTsgoBinEntry(pkg);
+    const candidates = [
+        declaredBinEntry ? external_path_default().resolve(pkgDir, declaredBinEntry) : void 0,
+        external_path_default().join(pkgDir, 'bin/tsgo.js')
+    ].filter((candidate)=>Boolean(candidate));
+    return candidates.find((candidate)=>utils_namespaceObject.fs.existsSync(candidate)) ?? candidates[0];
+};
+const getTsgoModulePath = (appDirectory, resolvePaths = [
+    appDirectory,
+    __dirname
+])=>{
+    const { name } = resolveTsgoPackage(resolvePaths);
+    return require.resolve(name, {
+        paths: resolvePaths
+    });
+};
+exports.createResolvedTsgoConfig = __webpack_exports__.createResolvedTsgoConfig;
+exports.getTsgoBinPath = __webpack_exports__.getTsgoBinPath;
+exports.getTsgoModulePath = __webpack_exports__.getTsgoModulePath;
+exports.runTsgo = __webpack_exports__.runTsgo;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createResolvedTsgoConfig",
+    "getTsgoBinPath",
+    "getTsgoModulePath",
+    "runTsgo"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/common/index.mjs

@@ -1,3 +1,4 @@
+import { logger } from "@modern-js/utils";
 import * as __rspack_external_path from "path";
 const FILE_EXTENSIONS = [
     '.js',
@@ -16,7 +17,17 @@ const compile = async (appDirectory, modernConfig, compileOptions)=>{
     validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
     validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
     validateAbsolutePaths(excludeFiles, (file)=>`excluded file ${file} is not an absolute path.`);
-    const { compileByTs } = await import("../compilers/typescript/index.mjs");
-    await compileByTs(appDirectory, modernConfig, compileOptions);
+    if (!tsconfigPath) return;
+    const { compileServerSources } = await import("../compilers/rslib.mjs");
+    try {
+        await compileServerSources(appDirectory, modernConfig, {
+            ...compileOptions,
+            tsconfigPath
+        });
+    } catch (error) {
+        if (compileOptions.throwErrorInsteadOfExit) throw error;
+        logger.error(error);
+        process.exit(1);
+    }
 };
 export { FILE_EXTENSIONS, compile };