mirror of
https://github.com/angular/angular-cli.git
synced 2025-05-22 15:02:11 +08:00
276 lines
13 KiB
JavaScript
276 lines
13 KiB
JavaScript
/// <reference path="../typings/node/node.d.ts" />
|
|
var fs = require('fs');
|
|
var fse = require('fs-extra');
|
|
var path = require('path');
|
|
var ts = require('typescript');
|
|
var diffing_broccoli_plugin_1 = require('./diffing-broccoli-plugin');
|
|
var notifier = require('node-notifier');
|
|
var FS_OPTS = {
|
|
encoding: 'utf-8'
|
|
};
|
|
/**
|
|
* Broccoli plugin that implements incremental Typescript compiler.
|
|
*
|
|
* It instantiates a typescript compiler instance that keeps all the state about the project and
|
|
* can re-emit only the files that actually changed.
|
|
*
|
|
* Limitations: only files that map directly to the changed source file via naming conventions are
|
|
* re-emitted. This primarily affects code that uses `const enum`s, because changing the enum value
|
|
* requires global emit, which can affect many files.
|
|
*/
|
|
var DiffingTSCompiler = (function () {
|
|
function DiffingTSCompiler(inputPath, cachePath, options) {
|
|
this.inputPath = inputPath;
|
|
this.cachePath = cachePath;
|
|
this.options = options;
|
|
this.fileRegistry = Object.create(null);
|
|
this.firstRun = true;
|
|
this.previousRunFailed = false;
|
|
if (options.rootFilePaths) {
|
|
this.rootFilePaths = options.rootFilePaths.splice(0);
|
|
delete options.rootFilePaths;
|
|
}
|
|
else {
|
|
this.rootFilePaths = [];
|
|
}
|
|
// the conversion is a bit awkward, see https://github.com/Microsoft/TypeScript/issues/5276
|
|
// in 1.8 use convertCompilerOptionsFromJson
|
|
this.tsOpts =
|
|
ts.parseJsonConfigFileContent({ compilerOptions: options, files: [] }, null, null).options;
|
|
// TODO: the above turns rootDir set to './' into an empty string - looks like a tsc bug
|
|
// check back when we upgrade to 1.7.x
|
|
if (this.tsOpts.rootDir === '') {
|
|
this.tsOpts.rootDir = './';
|
|
}
|
|
this.tsOpts.outDir = this.cachePath;
|
|
this.tsServiceHost = new CustomLanguageServiceHost(this.tsOpts, this.rootFilePaths, this.fileRegistry, this.inputPath);
|
|
this.tsService = ts.createLanguageService(this.tsServiceHost, ts.createDocumentRegistry());
|
|
this.config = require(path.resolve(this.cachePath, '..', '..', 'package.json'));
|
|
}
|
|
DiffingTSCompiler.prototype.rebuild = function (treeDiff) {
|
|
var _this = this;
|
|
var pathsToEmit = [];
|
|
var pathsWithErrors = [];
|
|
var errorMessages = [];
|
|
treeDiff.addedPaths.concat(treeDiff.changedPaths)
|
|
.forEach(function (tsFilePath) {
|
|
if (!_this.fileRegistry[tsFilePath]) {
|
|
_this.fileRegistry[tsFilePath] = { version: 0 };
|
|
_this.rootFilePaths.push(tsFilePath);
|
|
}
|
|
else {
|
|
_this.fileRegistry[tsFilePath].version++;
|
|
}
|
|
pathsToEmit.push(tsFilePath);
|
|
});
|
|
treeDiff.removedPaths.forEach(function (tsFilePath) {
|
|
console.log('removing outputs for', tsFilePath);
|
|
_this.rootFilePaths.splice(_this.rootFilePaths.indexOf(tsFilePath), 1);
|
|
_this.fileRegistry[tsFilePath] = null;
|
|
_this.removeOutputFor(tsFilePath);
|
|
});
|
|
if (this.firstRun) {
|
|
this.firstRun = false;
|
|
this.doFullBuild();
|
|
}
|
|
else {
|
|
pathsToEmit.forEach(function (tsFilePath) {
|
|
var output = _this.tsService.getEmitOutput(tsFilePath);
|
|
if (output.emitSkipped) {
|
|
var errorFound = _this.collectErrors(tsFilePath);
|
|
if (errorFound) {
|
|
pathsWithErrors.push(tsFilePath);
|
|
errorMessages.push(errorFound);
|
|
}
|
|
}
|
|
else {
|
|
output.outputFiles.forEach(function (o) {
|
|
var destDirPath = path.dirname(o.name);
|
|
fse.mkdirsSync(destDirPath);
|
|
fs.writeFileSync(o.name, _this.fixSourceMapSources(o.text), FS_OPTS);
|
|
});
|
|
}
|
|
});
|
|
if (pathsWithErrors.length) {
|
|
this.previousRunFailed = true;
|
|
var error = new Error('Typescript found the following errors:\n' + errorMessages.join('\n'));
|
|
error['showStack'] = false;
|
|
this.showNotification(errorMessages);
|
|
throw error;
|
|
}
|
|
else if (this.previousRunFailed) {
|
|
this.doFullBuild();
|
|
}
|
|
}
|
|
};
|
|
DiffingTSCompiler.prototype.collectErrors = function (tsFilePath) {
|
|
var allDiagnostics = this.tsService.getCompilerOptionsDiagnostics()
|
|
.concat(this.tsService.getSyntacticDiagnostics(tsFilePath))
|
|
.concat(this.tsService.getSemanticDiagnostics(tsFilePath));
|
|
var errors = [];
|
|
allDiagnostics.forEach(function (diagnostic) {
|
|
var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
|
|
if (diagnostic.file) {
|
|
var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
|
|
errors.push(" " + diagnostic.file.fileName + " (" + (line + 1) + "," + (character + 1) + "): " + message);
|
|
}
|
|
else {
|
|
errors.push(" Error: " + message);
|
|
}
|
|
});
|
|
if (errors.length) {
|
|
return errors.join('\n');
|
|
}
|
|
};
|
|
DiffingTSCompiler.prototype.doFullBuild = function () {
|
|
var _this = this;
|
|
var program = this.tsService.getProgram();
|
|
var emitResult = program.emit(undefined, function (absoluteFilePath, fileContent) {
|
|
fse.mkdirsSync(path.dirname(absoluteFilePath));
|
|
fs.writeFileSync(absoluteFilePath, _this.fixSourceMapSources(fileContent), FS_OPTS);
|
|
});
|
|
if (emitResult.emitSkipped) {
|
|
var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
|
|
var errorMessages = [];
|
|
allDiagnostics.forEach(function (diagnostic) {
|
|
var pos = '';
|
|
if (diagnostic.file) {
|
|
var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
|
|
pos = diagnostic.file.fileName + " (" + (line + 1) + ", " + (character + 1) + "): ";
|
|
}
|
|
var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
|
|
errorMessages.push(" " + pos + message);
|
|
});
|
|
if (errorMessages.length) {
|
|
this.previousRunFailed = true;
|
|
var error = new Error('Typescript found the following errors:\n' + errorMessages.join('\n'));
|
|
error['showStack'] = false;
|
|
this.showNotification(errorMessages);
|
|
throw error;
|
|
}
|
|
else {
|
|
this.previousRunFailed = false;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* There is a bug in TypeScript 1.6, where the sourceRoot and inlineSourceMap properties
|
|
* are exclusive. This means that the sources property always contains relative paths
|
|
* (e.g, ../../../../angular2/src/di/injector.ts).
|
|
*
|
|
* Here, we normalize the sources property and remove the ../../../
|
|
*
|
|
* This issue is fixed in https://github.com/Microsoft/TypeScript/pull/5620.
|
|
* Once we switch to TypeScript 1.8, we can remove this method.
|
|
*/
|
|
DiffingTSCompiler.prototype.fixSourceMapSources = function (content) {
|
|
try {
|
|
var marker = "//# sourceMappingURL=data:application/json;base64,";
|
|
var index = content.indexOf(marker);
|
|
if (index == -1)
|
|
return content;
|
|
var base = content.substring(0, index + marker.length);
|
|
var sourceMapBit = new Buffer(content.substring(index + marker.length), 'base64').toString("utf8");
|
|
var sourceMaps = JSON.parse(sourceMapBit);
|
|
var source = sourceMaps.sources[0];
|
|
sourceMaps.sources = [source.substring(source.lastIndexOf("../") + 3)];
|
|
return "" + base + new Buffer(JSON.stringify(sourceMaps)).toString('base64');
|
|
}
|
|
catch (e) {
|
|
return content;
|
|
}
|
|
};
|
|
DiffingTSCompiler.prototype.removeOutputFor = function (tsFilePath) {
|
|
var absoluteJsFilePath = path.join(this.cachePath, tsFilePath.replace(/\.ts$/, '.js'));
|
|
var absoluteMapFilePath = path.join(this.cachePath, tsFilePath.replace(/.ts$/, '.js.map'));
|
|
var absoluteDtsFilePath = path.join(this.cachePath, tsFilePath.replace(/\.ts$/, '.d.ts'));
|
|
if (fs.existsSync(absoluteJsFilePath)) {
|
|
fs.unlinkSync(absoluteJsFilePath);
|
|
fs.unlinkSync(absoluteMapFilePath);
|
|
fs.unlinkSync(absoluteDtsFilePath);
|
|
}
|
|
};
|
|
|
|
DiffingTSCompiler.prototype.showNotification = function (errorMessages) {
|
|
if (!this.config['angular-cli'].notifications.enabled) {
|
|
return;
|
|
}
|
|
|
|
notifier.notify({
|
|
title: 'Build Errors: ' + errorMessages.length,
|
|
message: errorMessages.map(function (msg) { return msg.trim(); }).join('\n'),
|
|
icon: path.resolve(__dirname, '..', '..', 'assets', 'angular.png'),
|
|
sound: this.config['angular-cli'].notifications.playSound,
|
|
wait: false
|
|
});
|
|
};
|
|
|
|
DiffingTSCompiler.includeExtensions = ['.ts'];
|
|
DiffingTSCompiler.excludeExtensions = ['.d.ts'];
|
|
return DiffingTSCompiler;
|
|
})();
|
|
var CustomLanguageServiceHost = (function () {
|
|
function CustomLanguageServiceHost(compilerOptions, fileNames, fileRegistry, treeInputPath) {
|
|
this.compilerOptions = compilerOptions;
|
|
this.fileNames = fileNames;
|
|
this.fileRegistry = fileRegistry;
|
|
this.treeInputPath = treeInputPath;
|
|
this.currentDirectory = process.cwd();
|
|
this.defaultLibFilePath = ts.getDefaultLibFilePath(compilerOptions).replace(/\\/g, '/');
|
|
}
|
|
CustomLanguageServiceHost.prototype.getScriptFileNames = function () { return this.fileNames; };
|
|
CustomLanguageServiceHost.prototype.getScriptVersion = function (fileName) {
|
|
return this.fileRegistry[fileName] && this.fileRegistry[fileName].version.toString();
|
|
};
|
|
/**
|
|
* This method is called quite a bit to lookup 3 kinds of paths:
|
|
* 1/ files in the fileRegistry
|
|
* - these are the files in our project that we are watching for changes
|
|
* - in the future we could add caching for these files and invalidate the cache when
|
|
* the file is changed lazily during lookup
|
|
* 2/ .d.ts and library files not in the fileRegistry
|
|
* - these are not our files, they come from tsd or typescript itself
|
|
* - these files change only rarely but since we need them very rarely, it's not worth the
|
|
* cache invalidation hassle to cache them
|
|
* 3/ bogus paths that typescript compiler tries to lookup during import resolution
|
|
* - these paths are tricky to cache since files come and go and paths that was bogus in the
|
|
* past might not be bogus later
|
|
*
|
|
* In the initial experiments the impact of this caching was insignificant (single digit %) and
|
|
* not worth the potential issues with stale cache records.
|
|
*/
|
|
CustomLanguageServiceHost.prototype.getScriptSnapshot = function (tsFilePath) {
|
|
var absoluteTsFilePath;
|
|
if (tsFilePath == this.defaultLibFilePath || path.isAbsolute(tsFilePath)) {
|
|
absoluteTsFilePath = tsFilePath;
|
|
}
|
|
else if (this.compilerOptions.moduleResolution === 2 /* NodeJs */ &&
|
|
tsFilePath.match(/^node_modules/)) {
|
|
absoluteTsFilePath = path.resolve(tsFilePath);
|
|
}
|
|
else if (tsFilePath.match(/^rxjs/)) {
|
|
absoluteTsFilePath = path.resolve('node_modules', tsFilePath);
|
|
}
|
|
else {
|
|
absoluteTsFilePath = path.join(this.treeInputPath, tsFilePath);
|
|
}
|
|
if (!fs.existsSync(absoluteTsFilePath)) {
|
|
// TypeScript seems to request lots of bogus paths during import path lookup and resolution,
|
|
// so we we just return undefined when the path is not correct.
|
|
return undefined;
|
|
}
|
|
return ts.ScriptSnapshot.fromString(fs.readFileSync(absoluteTsFilePath, FS_OPTS));
|
|
};
|
|
CustomLanguageServiceHost.prototype.getCurrentDirectory = function () { return this.currentDirectory; };
|
|
CustomLanguageServiceHost.prototype.getCompilationSettings = function () { return this.compilerOptions; };
|
|
CustomLanguageServiceHost.prototype.getDefaultLibFileName = function (options) {
|
|
// ignore options argument, options should not change during the lifetime of the plugin
|
|
return this.defaultLibFilePath;
|
|
};
|
|
return CustomLanguageServiceHost;
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = diffing_broccoli_plugin_1.wrapDiffingPlugin(DiffingTSCompiler);
|
|
|
|
//# sourceMappingURL=broccoli-typescript.js.map
|