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

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

@@ -1,257 +0,0 @@
-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";
-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, excludeFiles = [])=>{
-    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, excludeFiles);
-    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 = [], excludeFiles = [])=>{
-    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(path.sep).join(path.posix.sep));
-    const excludedPaths = new Set(excludeFiles.map((file)=>path.normalize(file).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 (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 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,
-    __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, compileOptions.excludeFiles);
-    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/compilers/typescript/tsconfigPathsPlugin.mjs

@@ -1,143 +0,0 @@
-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/esm-node/compilers/typescript/importRewriter.mjs

@@ -1,135 +0,0 @@
-import "node:module";
-import { parseSync } from "@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 = parseSync(content, parserOptions);
-    } catch (typescriptError) {
-        try {
-            program = 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
-    };
-};
-export { assertNoNativeModuleOutputCollision, rewriteImportSpecifiers };