597 lines
23 KiB
TypeScript
597 lines
23 KiB
TypeScript
// import all the stuff we need
|
||
import * as plugins from './plugins.js';
|
||
import * as paths from './paths.js';
|
||
import type { CompilerOptions, ScriptTarget, ModuleKind } from './tsbuild.exports.js';
|
||
|
||
/**
|
||
* Interface for error summary data
|
||
*/
|
||
export interface IErrorSummary {
|
||
errorsByFile: Record<string, plugins.typescript.Diagnostic[]>;
|
||
generalErrors: plugins.typescript.Diagnostic[];
|
||
totalErrors: number;
|
||
totalFiles: number;
|
||
}
|
||
|
||
/**
|
||
* Default compiler options for TypeScript compilation
|
||
*/
|
||
export const compilerOptionsDefault: CompilerOptions = {
|
||
declaration: true,
|
||
emitDecoratorMetadata: true,
|
||
experimentalDecorators: true,
|
||
inlineSourceMap: true,
|
||
noEmitOnError: true,
|
||
outDir: 'dist_ts/',
|
||
module: plugins.typescript.ModuleKind.NodeNext,
|
||
target: plugins.typescript.ScriptTarget.ESNext,
|
||
moduleResolution: plugins.typescript.ModuleResolutionKind.NodeNext,
|
||
lib: ['lib.dom.d.ts', 'lib.es2022.d.ts'],
|
||
noImplicitAny: false, // Allow implicit any by default
|
||
esModuleInterop: true,
|
||
useDefineForClassFields: false,
|
||
verbatimModuleSyntax: true,
|
||
baseUrl: './',
|
||
};
|
||
|
||
/**
|
||
* TsBuild class for handling TypeScript compilation
|
||
*/
|
||
export class TsBuild {
|
||
private fileNames: string[] = [];
|
||
private options: plugins.typescript.CompilerOptions;
|
||
private argvArg?: any;
|
||
private taskInfo?: any;
|
||
|
||
/**
|
||
* Create a new TsBuild instance
|
||
*/
|
||
constructor(
|
||
fileNames: string[] = [],
|
||
customOptions: CompilerOptions = {},
|
||
argvArg?: any,
|
||
taskInfo?: any
|
||
) {
|
||
this.fileNames = fileNames;
|
||
this.argvArg = argvArg;
|
||
this.taskInfo = taskInfo;
|
||
this.options = this.mergeCompilerOptions(customOptions, argvArg);
|
||
}
|
||
|
||
/**
|
||
* Helper function to read and process tsconfig.json
|
||
*/
|
||
private getTsConfigOptions(): CompilerOptions {
|
||
let tsconfig: any;
|
||
|
||
// Try to read tsconfig.json, but don't fail if it doesn't exist
|
||
try {
|
||
tsconfig = plugins.smartfile.fs.toObjectSync(plugins.path.join(paths.cwd, 'tsconfig.json'));
|
||
} catch (error) {
|
||
// tsconfig.json doesn't exist or is invalid - use defaults
|
||
return {};
|
||
}
|
||
|
||
if (!tsconfig || !tsconfig.compilerOptions) {
|
||
return {};
|
||
}
|
||
|
||
// Start by copying ALL compiler options from tsconfig.json
|
||
const returnObject: CompilerOptions = { ...tsconfig.compilerOptions };
|
||
|
||
// Apply special transformations for string-to-enum conversions
|
||
|
||
// Process target (convert string to enum)
|
||
if (tsconfig.compilerOptions.target && typeof tsconfig.compilerOptions.target === 'string') {
|
||
const targetKey = tsconfig.compilerOptions.target.toUpperCase();
|
||
if (targetKey in plugins.typescript.ScriptTarget) {
|
||
returnObject.target = plugins.typescript.ScriptTarget[targetKey as keyof typeof plugins.typescript.ScriptTarget];
|
||
}
|
||
}
|
||
|
||
// Process module (convert string to enum)
|
||
if (tsconfig.compilerOptions.module && typeof tsconfig.compilerOptions.module === 'string') {
|
||
const moduleKey = tsconfig.compilerOptions.module.toUpperCase();
|
||
if (moduleKey in plugins.typescript.ModuleKind) {
|
||
returnObject.module = plugins.typescript.ModuleKind[moduleKey as keyof typeof plugins.typescript.ModuleKind];
|
||
} else if (moduleKey === 'NODENEXT') {
|
||
returnObject.module = plugins.typescript.ModuleKind.NodeNext;
|
||
}
|
||
}
|
||
|
||
// Process moduleResolution (convert string to enum)
|
||
if (tsconfig.compilerOptions.moduleResolution && typeof tsconfig.compilerOptions.moduleResolution === 'string') {
|
||
const moduleResolutionKey = tsconfig.compilerOptions.moduleResolution.toUpperCase();
|
||
if (moduleResolutionKey in plugins.typescript.ModuleResolutionKind) {
|
||
returnObject.moduleResolution = plugins.typescript.ModuleResolutionKind[
|
||
moduleResolutionKey as keyof typeof plugins.typescript.ModuleResolutionKind
|
||
];
|
||
} else if (moduleResolutionKey === 'NODENEXT') {
|
||
returnObject.moduleResolution = plugins.typescript.ModuleResolutionKind.NodeNext;
|
||
}
|
||
}
|
||
|
||
// Apply path transformations (ts_ → dist_ts_)
|
||
if (tsconfig.compilerOptions.paths) {
|
||
returnObject.paths = { ...tsconfig.compilerOptions.paths };
|
||
for (const path of Object.keys(returnObject.paths)) {
|
||
if (Array.isArray(returnObject.paths[path]) && returnObject.paths[path].length > 0) {
|
||
returnObject.paths[path][0] = returnObject.paths[path][0].replace('./ts_', './dist_ts_');
|
||
}
|
||
}
|
||
}
|
||
|
||
return returnObject;
|
||
}
|
||
|
||
/**
|
||
* Returns critical default options that should not be overridden by tsconfig.json
|
||
* These options are essential for tsbuild's functionality and build integrity
|
||
*/
|
||
private getCriticalDefaults(): CompilerOptions {
|
||
return {
|
||
outDir: 'dist_ts/', // Required for path transformation logic
|
||
noEmitOnError: true, // Build integrity - prevent broken builds
|
||
declaration: true, // Library consumers depend on .d.ts files
|
||
emitDecoratorMetadata: true, // Required for dependency injection frameworks
|
||
inlineSourceMap: true, // Consistent debugging experience
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Process command line arguments and return applicable compiler options
|
||
*/
|
||
private getCommandLineOptions(argvArg?: any): CompilerOptions {
|
||
if (!argvArg) return {};
|
||
|
||
const options: CompilerOptions = {};
|
||
|
||
if (argvArg.skiplibcheck) {
|
||
options.skipLibCheck = true;
|
||
}
|
||
|
||
// Changed behavior: --disallowimplicitany instead of --allowimplicitany
|
||
if (argvArg.disallowimplicitany) {
|
||
options.noImplicitAny = true;
|
||
}
|
||
|
||
if (argvArg.commonjs) {
|
||
options.module = plugins.typescript.ModuleKind.CommonJS;
|
||
options.moduleResolution = plugins.typescript.ModuleResolutionKind.NodeJs;
|
||
}
|
||
|
||
return options;
|
||
}
|
||
|
||
/**
|
||
* Merges compilerOptions with the default compiler options
|
||
*
|
||
* Merge order (later overwrites earlier):
|
||
* 1. compilerOptionsDefault - Base defaults for all options
|
||
* 2. getTsConfigOptions() - User's tsconfig.json (all options)
|
||
* 3. getCriticalDefaults() - Protected options that shouldn't be overridden by tsconfig.json
|
||
* 4. customTsOptions - Programmatic options (can override critical defaults)
|
||
* 5. getCommandLineOptions() - CLI flags (highest priority)
|
||
*/
|
||
public mergeCompilerOptions(
|
||
customTsOptions: CompilerOptions = {},
|
||
argvArg?: any
|
||
): CompilerOptions {
|
||
// create merged options
|
||
const mergedOptions: CompilerOptions = {
|
||
...compilerOptionsDefault, // 1. All defaults
|
||
...this.getTsConfigOptions(), // 2. User's tsconfig.json (all options)
|
||
...this.getCriticalDefaults(), // 3. Protected overrides
|
||
...customTsOptions, // 4. Programmatic options
|
||
...this.getCommandLineOptions(argvArg), // 5. CLI flags (highest priority)
|
||
};
|
||
|
||
return mergedOptions;
|
||
}
|
||
|
||
/**
|
||
* Helper function to process TypeScript diagnostics and return error summary
|
||
*/
|
||
private processDiagnostics(diagnostics: readonly plugins.typescript.Diagnostic[]): IErrorSummary {
|
||
const errorsByFile: Record<string, plugins.typescript.Diagnostic[]> = {};
|
||
const generalErrors: plugins.typescript.Diagnostic[] = [];
|
||
|
||
// Categorize diagnostics
|
||
diagnostics.forEach((diagnostic) => {
|
||
if (diagnostic.file) {
|
||
const fileName = diagnostic.file.fileName;
|
||
if (!errorsByFile[fileName]) {
|
||
errorsByFile[fileName] = [];
|
||
}
|
||
errorsByFile[fileName].push(diagnostic);
|
||
} else {
|
||
generalErrors.push(diagnostic);
|
||
}
|
||
});
|
||
|
||
return {
|
||
errorsByFile,
|
||
generalErrors,
|
||
totalErrors: diagnostics.length,
|
||
totalFiles: Object.keys(errorsByFile).length
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Helper function to display error summary
|
||
*/
|
||
private displayErrorSummary(errorSummary: IErrorSummary): void {
|
||
if (errorSummary.totalErrors === 0) {
|
||
return;
|
||
}
|
||
|
||
const { errorsByFile, generalErrors, totalErrors, totalFiles } = errorSummary;
|
||
|
||
// Print error summary header
|
||
console.log('\n' + '='.repeat(80));
|
||
console.log(`❌ Found ${totalErrors} error${totalErrors !== 1 ? 's' : ''} in ${totalFiles} file${totalFiles !== 1 ? 's' : ''}:`);
|
||
console.log('='.repeat(80));
|
||
|
||
// Color codes for error formatting
|
||
const colors = {
|
||
reset: '\x1b[0m',
|
||
red: '\x1b[31m',
|
||
yellow: '\x1b[33m',
|
||
cyan: '\x1b[36m',
|
||
white: '\x1b[37m',
|
||
brightRed: '\x1b[91m'
|
||
};
|
||
|
||
// Print file-specific errors
|
||
Object.entries(errorsByFile).forEach(([fileName, fileErrors]) => {
|
||
// Show relative path if possible for cleaner output
|
||
const displayPath = fileName.replace(process.cwd(), '').replace(/^\//, '');
|
||
|
||
console.log(`\n${colors.cyan}File: ${displayPath} ${colors.yellow}(${fileErrors.length} error${fileErrors.length !== 1 ? 's' : ''})${colors.reset}`);
|
||
console.log('-'.repeat(80));
|
||
|
||
fileErrors.forEach((diagnostic) => {
|
||
if (diagnostic.file && diagnostic.start !== undefined) {
|
||
const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
|
||
const message = plugins.typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
|
||
const errorCode = diagnostic.code ? `TS${diagnostic.code}` : 'Error';
|
||
|
||
console.log(`${colors.white}Line ${line + 1}, Col ${character + 1}${colors.reset}: ${colors.brightRed}${errorCode}${colors.reset} - ${message}`);
|
||
|
||
// Try to show the code snippet if possible
|
||
try {
|
||
const lineContent = diagnostic.file.text.split('\n')[line];
|
||
if (lineContent) {
|
||
// Show the line of code
|
||
console.log(` ${lineContent.trimRight()}`);
|
||
|
||
// Show the error position indicator
|
||
const indicator = ' '.repeat(character) + `${colors.red}^${colors.reset}`;
|
||
console.log(` ${indicator}`);
|
||
}
|
||
} catch (e) {
|
||
// Failed to get source text, skip showing the code snippet
|
||
}
|
||
}
|
||
});
|
||
});
|
||
|
||
// Print general errors
|
||
if (generalErrors.length > 0) {
|
||
console.log(`\n${colors.yellow}General Errors:${colors.reset}`);
|
||
console.log('-'.repeat(80));
|
||
|
||
generalErrors.forEach((diagnostic) => {
|
||
const message = plugins.typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
|
||
const errorCode = diagnostic.code ? `TS${diagnostic.code}` : 'Error';
|
||
console.log(`${colors.brightRed}${errorCode}${colors.reset}: ${message}`);
|
||
});
|
||
}
|
||
|
||
console.log('\n' + '='.repeat(80) + '\n');
|
||
}
|
||
|
||
|
||
/**
|
||
* Creates a TypeScript program from file names and options
|
||
*/
|
||
private createProgram(
|
||
options: plugins.typescript.CompilerOptions = this.options
|
||
): plugins.typescript.Program {
|
||
return plugins.typescript.createProgram(this.fileNames, options);
|
||
}
|
||
|
||
/**
|
||
* Set file names to be compiled
|
||
*/
|
||
public setFileNames(fileNames: string[]): void {
|
||
this.fileNames = fileNames;
|
||
}
|
||
|
||
/**
|
||
* Set compiler options
|
||
*/
|
||
public setOptions(options: CompilerOptions): void {
|
||
this.options = { ...this.options, ...options };
|
||
}
|
||
|
||
/**
|
||
* The main compiler function that compiles the files and returns error summary
|
||
*/
|
||
public async compileWithErrorTracking(): Promise<{ emittedFiles: any[], errorSummary: IErrorSummary }> {
|
||
if (this.options.skipLibCheck) {
|
||
if (this.argvArg?.confirmskiplibcheck) {
|
||
console.log('\n⚠️ WARNING ⚠️');
|
||
console.log('You are skipping libcheck... Is that really wanted?');
|
||
console.log('Continuing in 5 seconds...\n');
|
||
await plugins.smartdelay.delayFor(5000);
|
||
} else {
|
||
// No delay by default; keep a short note unless in quiet/json modes
|
||
if (!this.argvArg?.quiet && !this.argvArg?.json) {
|
||
console.log('⚠️ skipLibCheck enabled; use --confirmskiplibcheck to pause with warning.');
|
||
}
|
||
}
|
||
}
|
||
|
||
// Enhanced logging with task info
|
||
const startTime = Date.now();
|
||
if (this.taskInfo) {
|
||
const { taskNumber, totalTasks, sourcePattern, destDir, fileCount } = this.taskInfo;
|
||
const relativeDestDir = destDir.replace(process.cwd(), '').replace(/^\//, '');
|
||
console.log(`\n🔨 [${taskNumber}/${totalTasks}] Compiling ${fileCount} file${fileCount !== 1 ? 's' : ''} from ${sourcePattern}`);
|
||
console.log(` 📁 Output: ${relativeDestDir}`);
|
||
} else {
|
||
console.log(`🔨 Compiling ${this.fileNames.length} files...`);
|
||
}
|
||
|
||
const done = plugins.smartpromise.defer<{ emittedFiles: any[], errorSummary: IErrorSummary }>();
|
||
const program = this.createProgram();
|
||
|
||
// Check for pre-emit diagnostics first
|
||
const preEmitDiagnostics = plugins.typescript.getPreEmitDiagnostics(program);
|
||
const preEmitErrorSummary = this.processDiagnostics(preEmitDiagnostics);
|
||
|
||
// Only continue to emit phase if no pre-emit errors
|
||
if (preEmitErrorSummary.totalErrors > 0) {
|
||
this.displayErrorSummary(preEmitErrorSummary);
|
||
console.error('\n❌ TypeScript pre-emit checks failed. Please fix the issues listed above before proceeding.');
|
||
console.error(' Type errors must be resolved before the compiler can emit output files.\n');
|
||
// Return error summary instead of exiting to allow final summary display
|
||
done.resolve({ emittedFiles: [], errorSummary: preEmitErrorSummary });
|
||
return done.promise;
|
||
}
|
||
|
||
// If no pre-emit errors, proceed with emit
|
||
const emitResult = program.emit();
|
||
const emitErrorSummary = this.processDiagnostics(emitResult.diagnostics);
|
||
|
||
// Combine error summaries
|
||
const combinedErrorSummary: IErrorSummary = {
|
||
errorsByFile: { ...preEmitErrorSummary.errorsByFile, ...emitErrorSummary.errorsByFile },
|
||
generalErrors: [...preEmitErrorSummary.generalErrors, ...emitErrorSummary.generalErrors],
|
||
totalErrors: preEmitErrorSummary.totalErrors + emitErrorSummary.totalErrors,
|
||
totalFiles: Object.keys({ ...preEmitErrorSummary.errorsByFile, ...emitErrorSummary.errorsByFile }).length
|
||
};
|
||
|
||
const exitCode = emitResult.emitSkipped ? 1 : 0;
|
||
if (exitCode === 0) {
|
||
const endTime = Date.now();
|
||
const duration = endTime - startTime;
|
||
|
||
if (this.taskInfo) {
|
||
const { taskNumber, totalTasks } = this.taskInfo;
|
||
console.log(`✅ [${taskNumber}/${totalTasks}] Task completed in ${duration}ms`);
|
||
} else {
|
||
console.log(`✅ TypeScript emit succeeded! (${duration}ms)`);
|
||
}
|
||
|
||
// Get count of emitted files by type
|
||
const jsFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.js')).length || 0;
|
||
const dtsFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.d.ts')).length || 0;
|
||
const mapFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.map')).length || 0;
|
||
|
||
// If we have emitted files, show a summary
|
||
if (emitResult.emittedFiles && emitResult.emittedFiles.length > 0) {
|
||
console.log(` 📄 Generated ${emitResult.emittedFiles.length} files: ${jsFiles} .js, ${dtsFiles} .d.ts, ${mapFiles} source maps`);
|
||
}
|
||
|
||
done.resolve({ emittedFiles: emitResult.emittedFiles || [], errorSummary: combinedErrorSummary });
|
||
} else {
|
||
this.displayErrorSummary(combinedErrorSummary);
|
||
console.error('\n❌ TypeScript emit failed. Please investigate the errors listed above!');
|
||
console.error(' No output files have been generated.\n');
|
||
// Do not exit here; return error summary so caller can decide
|
||
done.resolve({ emittedFiles: [], errorSummary: combinedErrorSummary });
|
||
return done.promise;
|
||
}
|
||
|
||
return done.promise;
|
||
}
|
||
|
||
/**
|
||
* The main compiler function that compiles the files
|
||
*/
|
||
public async compile(): Promise<any[]> {
|
||
if (this.options.skipLibCheck) {
|
||
if (this.argvArg?.confirmskiplibcheck) {
|
||
console.log('\n⚠️ WARNING ⚠️');
|
||
console.log('You are skipping libcheck... Is that really wanted?');
|
||
console.log('Continuing in 5 seconds...\n');
|
||
await plugins.smartdelay.delayFor(5000);
|
||
} else {
|
||
if (!this.argvArg?.quiet && !this.argvArg?.json) {
|
||
console.log('⚠️ skipLibCheck enabled; use --confirmskiplibcheck to pause with warning.');
|
||
}
|
||
}
|
||
}
|
||
|
||
console.log(`🔨 Compiling ${this.fileNames.length} files...`);
|
||
const done = plugins.smartpromise.defer<any[]>();
|
||
const program = this.createProgram();
|
||
|
||
// Check for pre-emit diagnostics first
|
||
const preEmitDiagnostics = plugins.typescript.getPreEmitDiagnostics(program);
|
||
const preEmitErrorSummary = this.processDiagnostics(preEmitDiagnostics);
|
||
|
||
// Only continue to emit phase if no pre-emit errors
|
||
if (preEmitErrorSummary.totalErrors > 0) {
|
||
this.displayErrorSummary(preEmitErrorSummary);
|
||
console.error('\n❌ TypeScript pre-emit checks failed. Please fix the issues listed above before proceeding.');
|
||
console.error(' Type errors must be resolved before the compiler can emit output files.\n');
|
||
// Throw instead of exiting to keep library pure
|
||
throw new Error('TypeScript pre-emit checks failed.');
|
||
}
|
||
|
||
// If no pre-emit errors, proceed with emit
|
||
const emitResult = program.emit();
|
||
const emitErrorSummary = this.processDiagnostics(emitResult.diagnostics);
|
||
|
||
const exitCode = emitResult.emitSkipped ? 1 : 0;
|
||
if (exitCode === 0) {
|
||
console.log('\n✅ TypeScript emit succeeded!');
|
||
|
||
// Get count of emitted files by type
|
||
const jsFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.js')).length || 0;
|
||
const dtsFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.d.ts')).length || 0;
|
||
const mapFiles = emitResult.emittedFiles?.filter(f => f.endsWith('.map')).length || 0;
|
||
|
||
// If we have emitted files, show a summary
|
||
if (emitResult.emittedFiles && emitResult.emittedFiles.length > 0) {
|
||
console.log(` Generated ${emitResult.emittedFiles.length} files: ${jsFiles} .js, ${dtsFiles} .d.ts, ${mapFiles} source maps`);
|
||
}
|
||
|
||
done.resolve(emitResult.emittedFiles);
|
||
} else {
|
||
this.displayErrorSummary(emitErrorSummary);
|
||
console.error('\n❌ TypeScript emit failed. Please investigate the errors listed above!');
|
||
console.error(' No output files have been generated.\n');
|
||
// Throw instead of exiting to keep library pure
|
||
throw new Error('TypeScript emit failed.');
|
||
}
|
||
|
||
return done.promise;
|
||
}
|
||
|
||
/**
|
||
* Function to check if files can be emitted without actually emitting them
|
||
*/
|
||
public async checkEmit(): Promise<boolean> {
|
||
const fileCount = this.fileNames.length;
|
||
console.log(`\n🔍 Checking if ${fileCount} file${fileCount !== 1 ? 's' : ''} can be emitted...`);
|
||
|
||
// Create a program with noEmit option
|
||
const program = this.createProgram({
|
||
...this.options,
|
||
noEmit: true
|
||
});
|
||
|
||
// Check for pre-emit diagnostics
|
||
const preEmitDiagnostics = plugins.typescript.getPreEmitDiagnostics(program);
|
||
const preEmitErrorSummary = this.processDiagnostics(preEmitDiagnostics);
|
||
|
||
// Run the emit phase but with noEmit: true to check for emit errors without producing files
|
||
const emitResult = program.emit(undefined, undefined, undefined, true);
|
||
const emitErrorSummary = this.processDiagnostics(emitResult.diagnostics);
|
||
|
||
// Combine error summaries
|
||
const combinedErrorSummary: IErrorSummary = {
|
||
errorsByFile: { ...preEmitErrorSummary.errorsByFile, ...emitErrorSummary.errorsByFile },
|
||
generalErrors: [...preEmitErrorSummary.generalErrors, ...emitErrorSummary.generalErrors],
|
||
totalErrors: preEmitErrorSummary.totalErrors + emitErrorSummary.totalErrors,
|
||
totalFiles: Object.keys({ ...preEmitErrorSummary.errorsByFile, ...emitErrorSummary.errorsByFile }).length
|
||
};
|
||
|
||
const success = combinedErrorSummary.totalErrors === 0 && !emitResult.emitSkipped;
|
||
|
||
if (success) {
|
||
console.log('\n✅ TypeScript emit check passed! All files can be emitted successfully.');
|
||
console.log(` ${fileCount} file${fileCount !== 1 ? 's' : ''} ${fileCount !== 1 ? 'are' : 'is'} ready to be compiled.\n`);
|
||
} else {
|
||
this.displayErrorSummary(combinedErrorSummary);
|
||
console.error('\n❌ TypeScript emit check failed. Please fix the issues listed above.');
|
||
console.error(' The compilation cannot proceed until these errors are resolved.\n');
|
||
}
|
||
|
||
return success;
|
||
}
|
||
|
||
/**
|
||
* Function to check TypeScript files for type errors without emission
|
||
*/
|
||
public async checkTypes(): Promise<boolean> {
|
||
const fileCount = this.fileNames.length;
|
||
console.log(`\n🔍 Type checking ${fileCount} TypeScript file${fileCount !== 1 ? 's' : ''}...`);
|
||
|
||
// Create a program with noEmit option explicitly set
|
||
const program = this.createProgram({
|
||
...this.options,
|
||
noEmit: true
|
||
});
|
||
|
||
// Check for type errors
|
||
const diagnostics = plugins.typescript.getPreEmitDiagnostics(program);
|
||
const errorSummary = this.processDiagnostics(diagnostics);
|
||
|
||
// Set success flag
|
||
const success = errorSummary.totalErrors === 0;
|
||
|
||
if (success) {
|
||
console.log('\n✅ TypeScript type check passed! No type errors found.');
|
||
console.log(` All ${fileCount} file${fileCount !== 1 ? 's' : ''} passed type checking successfully.\n`);
|
||
} else {
|
||
this.displayErrorSummary(errorSummary);
|
||
console.error('\n❌ TypeScript type check failed. Please fix the type errors listed above.');
|
||
console.error(' The type checker found issues that need to be resolved.\n');
|
||
}
|
||
|
||
return success;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Merges compilerOptions with the default compiler options (backward compatibility)
|
||
*/
|
||
export const mergeCompilerOptions = (
|
||
customTsOptions: CompilerOptions,
|
||
argvArg?: any
|
||
): CompilerOptions => {
|
||
const tsBuild = new TsBuild();
|
||
return tsBuild.mergeCompilerOptions(customTsOptions, argvArg);
|
||
};
|
||
|
||
/**
|
||
* The internal main compiler function that compiles the files (backward compatibility)
|
||
*/
|
||
export const compiler = async (
|
||
fileNames: string[],
|
||
options: plugins.typescript.CompilerOptions,
|
||
argvArg?: any
|
||
): Promise<any[]> => {
|
||
const tsBuild = new TsBuild(fileNames, options, argvArg);
|
||
return tsBuild.compile();
|
||
};
|
||
|
||
/**
|
||
* Function to check if a TypeScript file can be emitted without actually emitting it (backward compatibility)
|
||
*/
|
||
export const emitCheck = async (
|
||
fileNames: string[],
|
||
options: plugins.typescript.CompilerOptions = {},
|
||
argvArg?: any
|
||
): Promise<boolean> => {
|
||
const tsBuild = new TsBuild(fileNames, options, argvArg);
|
||
return tsBuild.checkEmit();
|
||
};
|
||
|
||
/**
|
||
* Function to check TypeScript files for type errors without emission (backward compatibility)
|
||
*/
|
||
export const checkTypes = async (
|
||
fileNames: string[],
|
||
options: plugins.typescript.CompilerOptions = {},
|
||
argvArg?: any
|
||
): Promise<boolean> => {
|
||
const tsBuild = new TsBuild(fileNames, options, argvArg);
|
||
return tsBuild.checkTypes();
|
||
};
|