@bleedingdev/modern-js-server-utils 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -1,262 +0,0 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { fs, getAliasConfig, logger } from "@modern-js/utils";
-import { spawn } from "child_process";
-import path from "path";
-import { assertNoNativeModuleOutputCollision, rewriteImportSpecifiers } from "./importRewriter.mjs";
-import { createTsconfigPathsMatcher, getNotAliasedPath } from "./tsconfigPathsPlugin.mjs";
-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));
-const copyFiles = async (from, to, appDirectory)=>{
-    if (await fs.pathExists(from)) {
-        const relativePath = path.relative(appDirectory, from);
-        const targetDir = path.join(to, relativePath);
-        await fs.copy(from, targetDir, {
-            filter: (src)=>!/\.(?:[cm]?ts|tsx|jsx?)$/u.test(src) && !src.endsWith('tsconfig.json')
-        });
-    }
-};
-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: tsconfigDir
-    });
-    const config = JSON.parse(output.stdout);
-    config.compilerOptions ??= {};
-    config.compilerOptions.rootDir = appDirectory;
-    config.compilerOptions.outDir = distDir;
-    config.compilerOptions.composite = false;
-    config.compilerOptions.declarationMap = false;
-    config.compilerOptions.emitDeclarationOnly = false;
-    config.compilerOptions.incremental = false;
-    config.compilerOptions.noEmit = false;
-    if (void 0 === config.compilerOptions.jsx || 'preserve' === config.compilerOptions.jsx) config.compilerOptions.jsx = 'react-jsx';
-    delete config.compilerOptions.tsBuildInfoFile;
-    if (true === config.compilerOptions.allowImportingTsExtensions) config.compilerOptions.rewriteRelativeImportExtensions = true;
-    config.files = filterSourceFiles(tsconfigDir, sourceDirs, config.files);
-    delete config.include;
-    delete config.references;
-    delete config.compilerOptions.baseUrl;
-    if ([
-        'node',
-        'node10'
-    ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
-    if ('module' !== moduleType) {
-        if ([
-            'preserve',
-            'esnext',
-            'es2015',
-            'es2020',
-            'es2022',
-            'es6'
-        ].includes(String(config.compilerOptions.module).toLowerCase())) {
-            config.compilerOptions.module = 'commonjs';
-            delete config.compilerOptions.moduleResolution;
-        }
-        config.compilerOptions.verbatimModuleSyntax = false;
-    }
-    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 = (tsconfigDir, sourceDirs, files = [])=>{
-    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path.sep).join(path.posix.sep));
-    return files.filter((fileName)=>{
-        const absoluteFileName = path.resolve(tsconfigDir, fileName).split(path.sep).join(path.posix.sep);
-        if (isAppRouterGeneratedDeclaration(absoluteFileName)) return false;
-        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
-    });
-};
-const isAppRouterGeneratedDeclaration = (absoluteFileName)=>/\/src\/modern-tanstack\/.*\.gen\.d\.ts$/u.test(absoluteFileName);
-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 resolveTsgoBinPath = (pkgPath)=>{
-    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 getTsgoBinPath = (appDirectory, resolvePaths = [
-    appDirectory,
-    __rspack_import_meta_dirname__
-])=>{
-    try {
-        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" (or legacy "@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'
-    ],
-    '.d.ts': [
-        '.ts',
-        '.tsx',
-        '.js',
-        '.jsx'
-    ],
-    '.d.mts': [
-        '.mts',
-        '.mjs'
-    ],
-    '.d.cts': [
-        '.cts',
-        '.cjs'
-    ]
-};
-const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
-    const relativeOutput = path.relative(distDir, outputFile);
-    const parsed = path.parse(relativeOutput);
-    const isDeclaration = parsed.name.endsWith('.d');
-    const outputExtension = isDeclaration ? `.d${parsed.ext}` : parsed.ext;
-    const sourceName = isDeclaration ? parsed.name.slice(0, -2) : parsed.name;
-    const sourceBase = path.join(appDirectory, parsed.dir, sourceName);
-    const extensions = OUTPUT_SOURCE_EXTENSIONS[outputExtension] ?? 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 rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
-    if (!await fs.pathExists(distDir)) return;
-    const matcher = createTsconfigPathsMatcher(baseUrl, paths);
-    if (!matcher) return;
-    const files = await collectOutputFiles(distDir);
-    await Promise.all(files.map(async (file)=>{
-        const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
-        if (!sourceFile) return;
-        assertNoNativeModuleOutputCollision(sourceFile, fs.existsSync);
-        const content = await fs.readFile(file, 'utf8');
-        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)=>{
-    const entries = await fs.readdir(dir, {
-        withFileTypes: true
-    });
-    const files = await Promise.all(entries.map(async (entry)=>{
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) return collectOutputFiles(fullPath);
-        return /\.(?:c|m)?js$|\.d\.(?:c|m)?ts$/.test(entry.name) ? [
-            fullPath
-        ] : [];
-    }));
-    return files.flat();
-};
-const compileByTs = async (appDirectory, config, compileOptions)=>{
-    logger.info("Running tsgo compile...");
-    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
-    if (!tsconfigPath) return;
-    const { alias } = config;
-    const aliasOption = getAliasConfig(alias, {
-        appDirectory,
-        tsconfigPath
-    });
-    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
-    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);
-    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
-    if (0 !== result.code) {
-        const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
-        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);
-    }
-    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
-    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
-    logger.info("TS-Go compile succeed");
-};
-export { compileByTs, createResolvedTsgoConfig, getTsgoBinPath, rewriteOutputSpecifiers };

package/dist/esm-node/compilers/typescript/tsconfigPathsPlugin.mjs

@@ -1,145 +0,0 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { findMatchedSourcePath, findSourceEntry } from "@modern-js/utils";
-import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
-import path from "path";
-const windowsAbsolutePathRE = /^[A-Za-z]:[\\/]/u;
-const isAbsolutePath = (input)=>path.isAbsolute(input) || path.win32.isAbsolute(input);
-const pathApiFor = (...inputs)=>inputs.some((input)=>windowsAbsolutePathRE.test(input)) ? path.win32 : path;
-const toImportSpecifier = (sourceFile, resolvedPath)=>{
-    const pathApi = pathApiFor(sourceFile, resolvedPath);
-    const relativePath = pathApi.relative(pathApi.dirname(sourceFile), resolvedPath).split(pathApi.sep).join(path.posix.sep);
-    return '.' === relativePath[0] ? relativePath : `./${relativePath}`;
-};
-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 = (findSourceEntry(resolvedPath) || resolvedPath).replace(/\\/g, '/');
-    const ext = path.extname(sourcePath);
-    if (!ext) return `${sourcePath}.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;
-    const pathApi = pathApiFor(sourceFile);
-    return pathApi.resolve(pathApi.dirname(sourceFile), text);
-};
-const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
-const resolveAliasPath = (baseUrl, filePath)=>{
-    if (filePath.startsWith('.') || filePath.startsWith('..')) return path.resolve(baseUrl, filePath);
-    return filePath;
-};
-const createAliasMatcher = (baseUrl, alias)=>{
-    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
-        if (isRegExpKey(key)) {
-            const regexp = new RegExp(key);
-            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                regexp,
-                aliasPath
-            ]);
-        } else {
-            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                key,
-                aliasPath
-            ]);
-        }
-        return o;
-    }, []);
-    const cacheMap = new Map();
-    return (requestedModule)=>{
-        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
-        for (const [key, value] of aliasPairs){
-            if (key instanceof RegExp) {
-                if (key.test(requestedModule)) {
-                    cacheMap.set(requestedModule, value);
-                    return value;
-                }
-            }
-            if (requestedModule === key) {
-                cacheMap.set(requestedModule, value);
-                return value;
-            }
-        }
-    };
-};
-const createTsconfigPathsMatcher = (baseUrl, paths)=>{
-    const tsPaths = {};
-    const alias = {};
-    Object.keys(paths).forEach((key)=>{
-        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
-        else alias[key] = paths[key];
-    });
-    const matchAliasPath = createAliasMatcher(baseUrl, alias);
-    const matchTsPath = createMatchPath(baseUrl, tsPaths, [
-        'main'
-    ]);
-    return (requestedModule, readJSONSync, fileExists, extensions)=>{
-        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
-        if (result) return result;
-        return matchAliasPath(requestedModule);
-    };
-};
-function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
-    let result = findMatchedSourcePath(matcher, text);
-    if (!result && 'module' === moduleType) result = resolveRelativeEsmSpecifier(sourceFile, text);
-    if (!result) return;
-    if (!isAbsolutePath(result)) {
-        if (!result.startsWith('.') && !result.startsWith('..')) try {
-            const packagePath = require.resolve(result, {
-                paths: [
-                    process.cwd(),
-                    ...module.paths
-                ]
-            });
-            if (packagePath) return result;
-        } catch  {}
-        try {
-            const packagePath = require.resolve(text, {
-                paths: [
-                    process.cwd(),
-                    ...module.paths
-                ]
-            });
-            if (packagePath) return text;
-        } catch  {}
-    }
-    if ('module' === moduleType || /\.[cm]ts$/iu.test(result)) result = toEsmOutputPath(result);
-    return toImportSpecifier(sourceFile, result) || './';
-}
-export { createTsconfigPathsMatcher, getNotAliasedPath };

package/dist/types/compilers/typescript/importRewriter.d.ts

@@ -1,8 +0,0 @@
-type SpecifierRewrite = (specifier: string) => string | undefined;
-export declare const assertNoNativeModuleOutputCollision: (sourceFile: string, fileExists: (file: string) => boolean) => void;
-/** Rewrite static module specifiers without touching runtime data or syntax. */
-export declare const rewriteImportSpecifiers: (content: string, rewrite: SpecifierRewrite) => {
-    content: string;
-    changed: boolean;
-};
-export {};

package/dist/types/compilers/typescript/index.d.ts

@@ -1,35 +0,0 @@
-import type { CompileFunc } from '../../common/index.js';
-type TsgoConfig = {
-    compilerOptions?: {
-        allowImportingTsExtensions?: boolean;
-        baseUrl?: unknown;
-        composite?: boolean;
-        declaration?: boolean;
-        declarationMap?: boolean;
-        emitDeclarationOnly?: boolean;
-        incremental?: boolean;
-        jsx?: string;
-        module?: string;
-        moduleResolution?: string;
-        noEmit?: boolean;
-        noEmitOnError?: boolean;
-        outDir?: string;
-        rootDir?: string;
-        rewriteRelativeImportExtensions?: boolean;
-        tsBuildInfoFile?: string;
-        verbatimModuleSyntax?: boolean;
-    };
-    files?: string[];
-    include?: string[];
-    references?: Array<{
-        path: string;
-    }>;
-};
-export declare const createResolvedTsgoConfig: (appDirectory: string, tsconfigPath: string, distDir: string, sourceDirs: string[], moduleType: 'module' | 'commonjs' | undefined, tsgoBinPath: string) => Promise<{
-    config: TsgoConfig;
-    resolvedConfigPath: string;
-}>;
-export declare const getTsgoBinPath: (appDirectory: string, resolvePaths?: string[]) => string;
-export declare const rewriteOutputSpecifiers: (appDirectory: string, distDir: string, baseUrl: string, paths: Record<string, string[] | string>, moduleType?: 'module' | 'commonjs') => Promise<void>;
-export declare const compileByTs: CompileFunc;
-export {};

package/dist/types/compilers/typescript/tsconfigPathsPlugin.d.ts

@@ -1,3 +0,0 @@
-import type { MatchPath } from '@modern-js/utils/tsconfig-paths';
-export declare const createTsconfigPathsMatcher: (baseUrl: string, paths: Record<string, string[] | string>) => MatchPath | undefined;
-export declare function getNotAliasedPath(sourceFile: string, matcher: MatchPath, text: string, moduleType?: 'module' | 'commonjs'): string | undefined;